Ошибки в коде - Expected class, delegate, enum, interface, or struct - C#

using System;
using System.Numerics;
 
namespace MyApp
{
    class Program
    {
        static void Main()
        {
 
        }
 
        static double[] W;
        static double[] X;
 
        //a-нижний предел интеграла (равен 0)
        //b - верхний предел интеграла. Выбирается значение от 100 до 200, в зависимости от нужной точности
        //delta - вычисляется грек дельта, который равен значению Р1 в формуле Хестона
        static double HestonCallGaussLegendre(double S, double K, double T, double r, double kappa, double theta,
                                    double sigma, double lambda, double v0, double rho, int trap,
                                    double a, double b, ref double delta)
        {
            // Числовое интегрирование
            double[] int1 = new double[32];
            double[] int2 = new double[32];
            double y;
            for (int k = 0; k <= 31; k++)
            {
                y = (a + b) / 2.0 + (b - a) / 2.0 * X[k];
                int1[k] = W[k] * HestonCF(y, S, K, r, T, rho, kappa, theta, lambda, sigma, v0, 1, trap);
                int2[k] = W[k] * HestonCF(y, S, K, r, T, rho, kappa, theta, lambda, sigma, v0, 2, trap);
            }
 
            // Векторы для интегральной суммы
            double I1 = VectorSum(int1);
            double I2 = VectorSum(int2);
 
            // Определение Р1 и Р2
            double P1 = 0.5 + 1.0 / Math.PI * I1 * (b - a) / 2;
            double P2 = 0.5 + 1.0 / Math.PI * I2 * (b - a) / 2;
            delta = P1;
 
            // Цена колл опциона
            return S * P1 - K * P2;
        }
        // Функция суммирования элементов вектора
        static double VectorSum(double[] A)
        {
            double sum = 0;
            double n = A.Length;
            for (int i = 0; i <= n - 1; i++)
                sum += A[i];
            return sum;
        }
 
        static double HestonCF(Complex phi, double Spot, double Strike,
                double Rate, double T, double Rho, double Kappa,
                double Theta, double Lambda, double Sigma, double V,
                int Pnum, int trap)
        {
            Complex S = new Complex(Spot, 0.0);    // Цена базового актива
            Complex K = new Complex(Strike, 0.0);    // Страйк
            Complex r = new Complex(Rate, 0.0);    // Безрисковая ставка (для марж. опционов =0)
            Complex tau = new Complex(T, 0.0);    // Период до экспирации в долях года
            Complex i = new Complex(0.0, 1.0);    // Мнимая переменная
            Complex rho = new Complex(Rho, 0.0);    // Параметр Хестона: Корреляция
            Complex kappa = new Complex(Kappa, 0.0);    // Параметр Хестона: Скорость возврата
            Complex theta = new Complex(Theta, 0.0);    // Параметр Хестона: уровень возвратности
            Complex lambda = new Complex(Lambda, 0.0);  // Параметр Хестона: мера риска (равна 0 для риск-нейтрального подхода)
            Complex sigma = new Complex(Sigma, 0.0);    // Параметр Хестона: Среднеквадратичное волатильности
            Complex v0 = new Complex(V, 0.0);           // Параметр Хестона: Текущая волатильность
            Complex two = new Complex(2.0, 0.0);    // число 2 в комплексной форме
            Complex one = new Complex(1.0, 0.0);        // число 1 в комплексной форме
            Complex y, a, u, b, sigma2, d, g, G, C, D, c, f;
            y = rho * sigma * phi * i;
            a = kappa * theta;
            if (Pnum == 1)
            {
                // Первая характеристическая функция
                u = 0.5;
                b = kappa + lambda - rho * sigma;
            }
            else
            {
                // Вторая характеристическая функция
                u = -0.5;
                b = kappa + lambda;
            }
            sigma2 = Complex.Pow(sigma, 2);
            d = Complex.Sqrt((y - b) * (y - b) - sigma2 * (two * u * phi * i - phi * phi));
            g = (b - y + d) / (b - y - d);
            if (trap == 1)
            {
                // Версия модели "Little Heston Trap"
                c = one / g;
                G = (one - c * Complex.Exp(-d * tau)) / (one - c);
                C = r * i * phi * tau + a / sigma2 * ((b - rho * sigma * i * phi - d) * tau - two * Complex.Log(G));
                D = (b - rho * sigma * i * phi - d) / sigma2 * ((one - Complex.Exp(-d * tau)) / (one - c * Complex.Exp(-d * tau)));
            }
            else
            {
                // Оригинальный вариант Хестона
                G = (one - g * Complex.Exp(d * tau)) / (one - g);
                C = r * i * phi * tau + a / sigma2 * ((b - rho * sigma * i * phi + d) * tau - two * Complex.Log(G));
                D = (b - rho * sigma * i * phi + d) / sigma2 * ((one - Complex.Exp(d * tau)) / (one - g * Complex.Exp(d * tau)));
            }
            f = Complex.Exp(C + D * v0 + i * phi * Complex.Log(S));
 
            // Вычисление реальной части подинтегрального выражения
            return (Complex.Exp(-i * phi * Complex.Log(K)) * f / i / phi).Real;
        }
    }
}