Вызов неуправляемого метода крашит программу

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApp2
{
    class Program
    {
        // wrap the unmanaged C++ functions in ErgDll.dll
        [DllImport("ErgDll.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr newObjectC();
 
        [DllImport("ErgDll.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern void delObjectC(IntPtr pI);
 
        [DllImport("ErgDll.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr getArgsAddresC(IntPtr pI);
 
        [DllImport("ErgDll.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern IntPtr getResultsAddresC(IntPtr pI);
 
        [DllImport("ErgDll.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int DoErgC(IntPtr pI);
 
        //+ BackgroundWorker
        static BackgroundWorker bw;
        static int st_nRet = 0;
        static void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Error != null)
                Console.WriteLine("Worker exception: " + e.Error);
            else
                Console.WriteLine("Работа закончена успешно"); // Результат - e.Result
            return;
        }
        static void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            st_nRet = DoErgC((IntPtr)e.Argument);
            e.Result = st_nRet;
        }
        //- BackgroundWorker
        static void Main(string[] args)
        {
            const int TMIN_FLAG = 1947000000;
 
            try
            {
                IntPtr pI = newObjectC();
                if (pI == IntPtr.Zero)
                {
                    Console.WriteLine("Error in newObject()");
                    return;
                }
                IntPtr pAdd = getArgsAddresC(pI);
                if (pAdd == IntPtr.Zero)
                {
                    Console.WriteLine("Error in getArgsAddresC(...)");
                    delObjectC(pI); pI = IntPtr.Zero;
                    return;
                }
                // Read data for Erg from text-file
                string textFile = "DatForErg.dat";
                if (args.Length > 0)
                    textFile = args[0];
                if (!File.Exists(textFile))
                {
                    Console.WriteLine("File {0} with data for Erg no founded", textFile);
                    return;
                }
                ReadWriteData RW = new ReadWriteData();
                if (RW.GetDatForErgDll(pAdd, textFile))
                {
                    //int result = DoErgC(pI);
 
                    //+ BackgroundWorker
                    st_nRet = 0;
                    bw = new BackgroundWorker();
                    bw.DoWork += bw_DoWork;
                    bw.RunWorkerCompleted += bw_RunWorkerCompleted;
                    bw.RunWorkerAsync(pI);
                    // Emulation useful work in Main Thread
                    const int SLEEP_AMOUNT = 100;
                    const int SLEEP_TIMEOUT = 90000; // 90 seconds
                    int elapsedTime = 0;
                    while (bw.IsBusy && elapsedTime < SLEEP_TIMEOUT)
                    {
                        elapsedTime += SLEEP_AMOUNT;
                        Thread.Sleep(SLEEP_AMOUNT); // <= Do something useful
                    }
                    int Res = st_nRet; // Without BackgroundWorker: int Res=DoErgC(pI);
                                       //- BackgroundWorker
                    if (0 == Res) // O'key
                    {
                        FileInfo fi = new FileInfo(textFile);
                        RW.ResultsFromERGtoFile(getResultsAddresC(pI), fi.DirectoryName);
                    }
                    else if (TMIN_FLAG < Res) // Заданное время хода T меньше минимального Tmin
                    {
                        Res -= TMIN_FLAG;
                        Console.WriteLine("Время хода T меньше минимального Tmin на {0} сек\n", Res);
                    }
                    else
                    {
                        // ... 
                    }
                }
 
                delObjectC(pI); pI = IntPtr.Zero;
            }
            catch (System.Exception ex)
            {
                Console.WriteLine("An error occurred trying to do Erg-calculation");
            }
        }
 
    }
    class ReadWriteData
    {
        public bool GetDatForErgDll(IntPtr pAdd, string textFile)
        {
            if (pAdd == IntPtr.Zero)
            {
                Console.WriteLine("Address is null");
                return false;
            }
            if (!File.Exists(textFile))
            {
                Console.WriteLine("File {0} with data for Erg no founded", textFile);
                return false;
            }
            IntPtr pTo = pAdd;
            string[] delimiterChars = { " ", "\t", "\r\n" };
            string[] words;
            using (StreamReader sr = new StreamReader(textFile))
            {
                string sAll = sr.ReadToEnd();
                sr.Close();
                words = sAll.Split(delimiterChars, StringSplitOptions.RemoveEmptyEntries);
            }
            int nC = words.Length, i = 0, j = 0, k, iTo = 0, nRows = 0;
            int[] pIntArr = new int[nC];
            double[] pDblArr = new double[256];
            // nLenMeters, VBeg, VEnd, VMax, Tx 
            for (j = 0; j < 5; ++j)
                pIntArr[iTo++] = int.Parse(words[i++]);
            // profil
            nRows = int.Parse(words[i++]); pIntArr[iTo++] = nRows;
            for (j = 0; j < 3 * nRows; ++j)
                pIntArr[iTo++] = int.Parse(words[i++]);
            // VLim
            nRows = int.Parse(words[i++]); pIntArr[iTo++] = nRows;
            for (j = 0; j < 3 * nRows; ++j)
                pIntArr[iTo++] = int.Parse(words[i++]);
            // Mp, Lp, MLok, LLok
            for (j = 0; j < 4; ++j)
                pIntArr[iTo++] = int.Parse(words[i++]);
            Marshal.Copy(pIntArr, 0, pTo, iTo);
            pTo = (IntPtr)(4 * iTo + pTo.ToInt32()); iTo = 0;
            // a1, a2, a3
 
 
            var culture = new CultureInfo("ru-Ru")
                {
                    NumberFormat =
                    {
                        CurrencyDecimalSeparator = "."
                    }
                };
            for (j = 0; j < 3; ++j)
                pDblArr[iTo++] = double.Parse(words[i++], NumberStyles.Any, culture);
            Marshal.Copy(pDblArr, 0, pTo, iTo); ;
            pTo = (IntPtr)(8 * iTo + pTo.ToInt32()); iTo = 0;
            // ntype
            pIntArr[iTo++] = int.Parse(words[i++]);
            // Vagons
            nRows = int.Parse(words[i++]); pIntArr[iTo++] = nRows;
            for (j = 0; j < 3 * nRows; ++j)
                pIntArr[iTo++] = int.Parse(words[i++]);
            Marshal.Copy(pIntArr, 0, pTo, iTo);
            pTo = (IntPtr)(4 * iTo + pTo.ToInt32()); iTo = 0;
            // Tg/Tm
            for (k = 0; k < 2; ++k) // k==0/1 ==> Tg/Tm
            {
                int n = int.Parse(words[i++]),
                    nU = int.Parse(words[i++]);
                pIntArr[iTo++] = n; pIntArr[iTo++] = nU;
                Marshal.Copy(pIntArr, 0, pTo, iTo);
                pTo = (IntPtr)(4 * iTo + pTo.ToInt32()); iTo = 0;
                for (j = 0; j < 2 * n; ++j)
                    pDblArr[iTo++] = double.Parse(words[i++], NumberStyles.Any, culture);
                Marshal.Copy(pDblArr, 0, pTo, iTo);
                pTo = (IntPtr)(8 * iTo + pTo.ToInt32()); iTo = 0;
                if (0 == nU) nU = 1;
                for (j = 0; j < nU; ++j)
                    pIntArr[iTo++] = int.Parse(words[i++]);
                Marshal.Copy(pIntArr, 0, pTo, iTo);
                pTo = (IntPtr)(4 * iTo + pTo.ToInt32()); iTo = 0;
            }
            // Parameters
            for (j = 0; j < 2; ++j)
                pIntArr[iTo++] = int.Parse(words[i++]);
            Marshal.Copy(pIntArr, 0, pTo, iTo);
            pTo = (IntPtr)(4 * iTo + pTo.ToInt32()); iTo = 0;
 
 
            var count = pTo.ToInt32() - pAdd.ToInt32();
            var bytes = new byte[count];
            Marshal.Copy(pAdd,bytes, 0, bytes.Length);
            File.WriteAllBytes("D:/mData.dat", bytes);
            return true;
        }
 
        public bool ResultsFromERGtoFile(IntPtr pAdd, string sPath)
        {
            if (pAdd == IntPtr.Zero)
            {
                Console.WriteLine("Address is null");
                return false;
            }
            IntPtr pFrom = pAdd;
            // to SVWT_Result.dat
            using (StreamWriter sw = new StreamWriter(sPath + "\\SVWT_Result.dat"))
            {
                string sFrm = "{0, 10} {1, 8} {2, 12} {3, 10}";
                int i = 0, nR = Marshal.ReadInt32(pFrom);
                pFrom = (IntPtr)(4 + pFrom.ToInt32());
                sw.WriteLine(nR);
                for (i = 0; i < nR; ++i)
                {
                    int s = 0, v = 0, w = 0, t = 0;
                    s = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    v = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    w = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    t = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    string sRow = string.Format(sFrm, s, v, w, t);
                    sw.WriteLine(sRow);
                }
            }
            // to REGS_Result.dat
            using (StreamWriter sr = new StreamWriter(sPath + "\\REGS_Result.dat"))
            {
                string sFrm = "{0, 10} {1, 8} {2, 8} {3, 10}    {4}";
                int i = 0, nR = Marshal.ReadInt32(pFrom);
                pFrom = (IntPtr)(4 + pFrom.ToInt32());
                sr.WriteLine(nR);
                for (i = 0; i < nR; ++i)
                {
                    int s = 0, v1 = 0, v2 = 0, t = 0;
                    s = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    v1 = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    v2 = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    t = Marshal.ReadInt32(pFrom); pFrom = (IntPtr)(4 + pFrom.ToInt32());
                    byte ch = Marshal.ReadByte(pFrom); pFrom = (IntPtr)(1 + pFrom.ToInt32());
                    string sRow = string.Format(sFrm, s, v1, v2, t, (char)ch);
                    sr.WriteLine(sRow);
                }
            }
 
            return true;
        }
 
    }
}