using Microsoft.CSharp.RuntimeBinder;

using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using System.Xml.Serialization;

namespace ShrlAlgo.RvKits.RvIndependent.MetroGauges.LandXMLData;

[XmlType("Curve")]
[Serializable]
public class Curve : Interval
{
    public Curve()
    {
        _points = new List<TextPoint2D>(4) { new(), new(), new(), new() };
    }

    public Curve(Curve entity)
        : this()
    {
        Length = entity.Length;
        Tangent = entity.Tangent;
        Radius = entity.Radius;
        MidOrd = entity.MidOrd;
        External = entity.External;
        DirStart = entity.DirStart;
        DirEnd = entity.DirEnd;
        Delta = entity.Delta;
        Chord = entity.Chord;
        Rot = entity.Rot;
        CrvType = entity.CrvType;
        Start = entity.Start;
        End = entity.End;
        PI = entity.PI;
        Center = entity.Center;
    }

    public Curve(dynamic entity, dynamic baseline, dynamic profile)
        : this()
    {
        Contructor.pSite1 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target = Contructor.pSite1.Target;
        CallSite pSite = Contructor.pSite1;
        Contructor.pSite2 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(CSharpBinderFlags.None, "Length", typeof(Curve), new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) })
        );

        Length = target(pSite, Contructor.pSite2.Target(Contructor.pSite2, entity));
        Contructor.pSite3 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target2 = Contructor.pSite3.Target;
        CallSite pSite2 = Contructor.pSite3;
        Contructor.pSite4 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "ExternalTangent",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Tangent = target2(pSite2, Contructor.pSite4.Target(Contructor.pSite4, entity));
        Contructor.pSite5 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target3 = Contructor.pSite5.Target;
        CallSite pSite3 = Contructor.pSite5;
        Contructor.pSite6 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(CSharpBinderFlags.None, "Radius", typeof(Curve), new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) })
        );

        Radius = target3(pSite3, Contructor.pSite6.Target(Contructor.pSite6, entity));
        Contructor.pSite7 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target4 = Contructor.pSite7.Target;
        CallSite pSite4 = Contructor.pSite7;
        Contructor.pSite8 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "MidOrdinate",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        MidOrd = target4(pSite4, Contructor.pSite8.Target(Contructor.pSite8, entity));
        Contructor.pSite9 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target5 = Contructor.pSite9.Target;
        CallSite pSite5 = Contructor.pSite9;
        Contructor.pSitea ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "ExternalSecant",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        External = target5(pSite5, Contructor.pSitea.Target(Contructor.pSitea, entity));
        Contructor.pSiteb ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target6 = Contructor.pSiteb.Target;
        CallSite pSiteb = Contructor.pSiteb;
        Contructor.pSitec ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Divide,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
                }
            )
        );

        Func<CallSite, object, double, object> target7 = Contructor.pSitec.Target;
        CallSite pSitec = Contructor.pSitec;
        Contructor.pSited ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Multiply,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
                }
            )
        );

        Func<CallSite, object, double, object> target8 = Contructor.pSited.Target;
        CallSite pSited = Contructor.pSited;
        Contructor.pSitee ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "StartDirection",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        DirStart = target6(pSiteb, target7(pSitec, target8(pSited, Contructor.pSitee.Target(Contructor.pSitee, entity), 180.0), 3.1415926535897931));
        Contructor.pSitef ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target9 = Contructor.pSitef.Target;
        CallSite pSitef = Contructor.pSitef;
        Contructor.pSite10 ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Divide,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
                }
            )
        );

        Func<CallSite, object, double, object> target10 = Contructor.pSite10.Target;
        CallSite pSite6 = Contructor.pSite10;
        Contructor.pSite11 ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Multiply,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
                }
            )
        );

        Func<CallSite, object, double, object> target11 = Contructor.pSite11.Target;
        CallSite pSite7 = Contructor.pSite11;
        Contructor.pSite12 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "EndDirection",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        DirEnd = target9(pSitef, target10(pSite6, target11(pSite7, Contructor.pSite12.Target(Contructor.pSite12, entity), 180.0), 3.1415926535897931));
        Contructor.pSite13 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target12 = Contructor.pSite13.Target;
        CallSite pSite8 = Contructor.pSite13;
        Contructor.pSite14 ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Divide,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
                }
            )
        );

        Func<CallSite, object, double, object> target13 = Contructor.pSite14.Target;
        CallSite pSite9 = Contructor.pSite14;
        Contructor.pSite15 ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Multiply,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
                }
            )
        );

        Func<CallSite, object, double, object> target14 = Contructor.pSite15.Target;
        CallSite pSite10 = Contructor.pSite15;
        Contructor.pSite16 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(CSharpBinderFlags.None, "Delta", typeof(Curve), new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) })
        );

        Delta = target12(pSite8, target13(pSite9, target14(pSite10, Contructor.pSite16.Target(Contructor.pSite16, entity), 180.0), 3.1415926535897931));
        Contructor.pSite17 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target15 = Contructor.pSite17.Target;
        CallSite pSite11 = Contructor.pSite17;
        Contructor.pSite18 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "ChordLength",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Chord = target15(pSite11, Contructor.pSite18.Target(Contructor.pSite18, entity));
        Contructor.pSite19 ??= CallSite<Func<CallSite, object, bool>>.Create(
            Binder.UnaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.IsTrue,
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Func<CallSite, object, bool> target16 = Contructor.pSite19.Target;
        CallSite pSite12 = Contructor.pSite19;
        Contructor.pSite1a ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "Clockwise",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Rot = target16(pSite12, Contructor.pSite1a.Target(Contructor.pSite1a, entity)) ? "cw" : "ccw";
        Contructor.pSite1b ??= CallSite<Func<CallSite, object, string>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(string), typeof(Curve)));

        Func<CallSite, object, string> target17 = Contructor.pSite1b.Target;
        CallSite pSite1b = Contructor.pSite1b;
        Contructor.pSite1c ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "ToString",
                null,
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Func<CallSite, object, object> target18 = Contructor.pSite1c.Target;
        CallSite pSite1c = Contructor.pSite1c;
        Contructor.pSite1d ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(CSharpBinderFlags.None, "Type", typeof(Curve), new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) })
        );

        CrvType = target17(pSite1b, target18(pSite1c, Contructor.pSite1d.Target(Contructor.pSite1d, entity)));
        Contructor.pSite1e ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target19 = Contructor.pSite1e.Target;
        CallSite pSite1e = Contructor.pSite1e;
        Contructor.pSite1f ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Multiply,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
                }
            )
        );

        Func<CallSite, object, double, object> target20 = Contructor.pSite1f.Target;
        CallSite pSite1f = Contructor.pSite1f;
        Contructor.pSite20 ??= CallSite<Func<CallSite, object, object, object>>.Create(
            Binder.BinaryOperation(
                CSharpBinderFlags.None,
                ExpressionType.Add,
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Func<CallSite, object, object, object> target21 = Contructor.pSite20.Target;
        CallSite pSite13 = Contructor.pSite20;
        Contructor.pSite21 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "StartingStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        object arg = Contructor.pSite21.Target(Contructor.pSite21, entity);
        Contructor.pSite22 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "EndingStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        double num = target19(pSite1e, target20(pSite1f, target21(pSite13, arg, Contructor.pSite22.Target(Contructor.pSite22, entity)), 0.5));
        Contructor.pSite23 ??= CallSite<Func<CallSite, object, double[], object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "StationOffsetElevationToXYZ",
                null,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, object, double[], object> target22 = Contructor.pSite23.Target;
        CallSite pSite14 = Contructor.pSite23;
        double[] array = new double[3];
        double[] array2 = array;
        int num2 = 0;
        Contructor.pSite24 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target23 = Contructor.pSite24.Target;
        CallSite pSite15 = Contructor.pSite24;
        Contructor.pSite25 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "StartingStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array2[num2] = target23(pSite15, Contructor.pSite25.Target(Contructor.pSite25, entity));
        double[] array3 = array;
        int num3 = 2;
        Contructor.pSite26 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target24 = Contructor.pSite26.Target;
        CallSite pSite16 = Contructor.pSite26;
        Contructor.pSite27 ??= CallSite<Func<CallSite, object, object, object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "ElevationAt",
                null,
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Func<CallSite, object, object, object> target25 = Contructor.pSite27.Target;
        CallSite pSite17 = Contructor.pSite27;
        Contructor.pSite28 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "StartingStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array3[num3] = target24(pSite16, target25(pSite17, profile, Contructor.pSite28.Target(Contructor.pSite28, entity)));
        object obj = target22(pSite14, baseline, array);
        Contructor.pSite29 ??= CallSite<Func<CallSite, object, double[], object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "StationOffsetElevationToXYZ",
                null,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, object, double[], object> target26 = Contructor.pSite29.Target;
        CallSite pSite18 = Contructor.pSite29;
        double[] array4 = new double[3];
        double[] array5 = array4;
        int num4 = 0;
        Contructor.pSite2a ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target27 = Contructor.pSite2a.Target;
        CallSite pSite2a = Contructor.pSite2a;
        Contructor.pSite2b ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "EndingStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array5[num4] = target27(pSite2a, Contructor.pSite2b.Target(Contructor.pSite2b, entity));
        double[] array6 = array4;
        int num5 = 2;
        Contructor.pSite2c ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target28 = Contructor.pSite2c.Target;
        CallSite pSite2c = Contructor.pSite2c;
        Contructor.pSite2d ??= CallSite<Func<CallSite, object, object, object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "ElevationAt",
                null,
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Func<CallSite, object, object, object> target29 = Contructor.pSite2d.Target;
        CallSite pSite2d = Contructor.pSite2d;
        Contructor.pSite2e ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "EndingStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array6[num5] = target28(pSite2c, target29(pSite2d, profile, Contructor.pSite2e.Target(Contructor.pSite2e, entity)));
        object obj2 = target26(pSite18, baseline, array4);
        Contructor.pSite2f ??= CallSite<Func<CallSite, object, double[], object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "StationOffsetElevationToXYZ",
                null,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, object, double[], object> target30 = Contructor.pSite2f.Target;
        CallSite pSite2f = Contructor.pSite2f;
        double[] array7 = new double[3];
        double[] array8 = array7;
        int num6 = 0;
        Contructor.pSite30 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target31 = Contructor.pSite30.Target;
        CallSite pSite19 = Contructor.pSite30;
        Contructor.pSite31 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "PIStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array8[num6] = target31(pSite19, Contructor.pSite31.Target(Contructor.pSite31, entity));
        double[] array9 = array7;
        int num7 = 2;
        Contructor.pSite32 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target32 = Contructor.pSite32.Target;
        CallSite pSite20 = Contructor.pSite32;
        Contructor.pSite33 ??= CallSite<Func<CallSite, object, object, object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "ElevationAt",
                null,
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null), CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        Func<CallSite, object, object, object> target33 = Contructor.pSite33.Target;
        CallSite pSite21 = Contructor.pSite33;
        Contructor.pSite34 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "PIStation",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array9[num7] = target32(pSite20, target33(pSite21, profile, Contructor.pSite34.Target(Contructor.pSite34, entity)));
        object obj3 = target30(pSite2f, baseline, array7);
        Contructor.pSite35 ??= CallSite<Func<CallSite, object, double[], object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "StationOffsetElevationToXYZ",
                null,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, object, double[], object> target34 = Contructor.pSite35.Target;
        CallSite pSite22 = Contructor.pSite35;
        double[] array10 = new double[3];
        array10[0] = num;
        double[] array11 = array10;
        int num8 = 2;
        Contructor.pSite36 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target35 = Contructor.pSite36.Target;
        CallSite pSite23 = Contructor.pSite36;
        Contructor.pSite37 ??= CallSite<Func<CallSite, object, double, object>>.Create(
            Binder.InvokeMember(
                CSharpBinderFlags.None,
                "ElevationAt",
                null,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        array11[num8] = target35(pSite23, Contructor.pSite37.Target(Contructor.pSite37, profile, num));
        object obj4 = target34(pSite22, baseline, array10);
        Contructor.pSite38 ??= CallSite<Func<CallSite, Type, object, double[], TextPoint2D>>.Create(
            Binder.InvokeConstructor(
                CSharpBinderFlags.None,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, Type, object, double[], TextPoint2D> target36 = Contructor.pSite38.Target;
        CallSite pSite24 = Contructor.pSite38;
        Type typeFromHandle = typeof(TextPoint2D);
        object arg2 = obj;
        double[] array12 = new double[2];
        double[] array13 = array12;
        int num9 = 0;
        Contructor.pSite39 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target37 = Contructor.pSite39.Target;
        CallSite pSite25 = Contructor.pSite39;
        Contructor.pSite3a ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "StartEasting",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array13[num9] = target37(pSite25, Contructor.pSite3a.Target(Contructor.pSite3a, entity));
        double[] array14 = array12;
        int num10 = 1;
        Contructor.pSite3b ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target38 = Contructor.pSite3b.Target;
        CallSite pSite3b = Contructor.pSite3b;
        Contructor.pSite3c ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "StartNorthing",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array14[num10] = target38(pSite3b, Contructor.pSite3c.Target(Contructor.pSite3c, entity));
        Start = target36(pSite24, typeFromHandle, arg2, array12);
        Contructor.pSite3d ??= CallSite<Func<CallSite, Type, object, double[], TextPoint2D>>.Create(
            Binder.InvokeConstructor(
                CSharpBinderFlags.None,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, Type, object, double[], TextPoint2D> target39 = Contructor.pSite3d.Target;
        CallSite pSite3d = Contructor.pSite3d;
        Type typeFromHandle2 = typeof(TextPoint2D);
        object arg3 = obj2;
        double[] array15 = new double[2];
        double[] array16 = array15;
        int num11 = 0;
        Contructor.pSite3e ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target40 = Contructor.pSite3e.Target;
        CallSite pSite3e = Contructor.pSite3e;
        Contructor.pSite3f ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "EndEasting",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array16[num11] = target40(pSite3e, Contructor.pSite3f.Target(Contructor.pSite3f, entity));
        double[] array17 = array15;
        int num12 = 1;
        Contructor.pSite40 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target41 = Contructor.pSite40.Target;
        CallSite pSite26 = Contructor.pSite40;
        Contructor.pSite41 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "EndNorthing",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array17[num12] = target41(pSite26, Contructor.pSite41.Target(Contructor.pSite41, entity));
        End = target39(pSite3d, typeFromHandle2, arg3, array15);
        Contructor.pSite42 ??= CallSite<Func<CallSite, Type, object, double[], TextPoint2D>>.Create(
            Binder.InvokeConstructor(
                CSharpBinderFlags.None,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, Type, object, double[], TextPoint2D> target42 = Contructor.pSite42.Target;
        CallSite pSite27 = Contructor.pSite42;
        Type typeFromHandle3 = typeof(TextPoint2D);
        object arg4 = obj3;
        double[] array18 = new double[2];
        double[] array19 = array18;
        int num13 = 0;
        Contructor.pSite43 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target43 = Contructor.pSite43.Target;
        CallSite pSite28 = Contructor.pSite43;
        Contructor.pSite44 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "PIEasting",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array19[num13] = target43(pSite28, Contructor.pSite44.Target(Contructor.pSite44, entity));
        double[] array20 = array18;
        int num14 = 1;
        Contructor.pSite45 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target44 = Contructor.pSite45.Target;
        CallSite pSite29 = Contructor.pSite45;
        Contructor.pSite46 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "PINorthing",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array20[num14] = target44(pSite29, Contructor.pSite46.Target(Contructor.pSite46, entity));
        PI = target42(pSite27, typeFromHandle3, arg4, array18);
        Contructor.pSite47 ??= CallSite<Func<CallSite, Type, object, double[], TextPoint2D>>.Create(
            Binder.InvokeConstructor(
                CSharpBinderFlags.None,
                typeof(Curve),
                new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.IsStaticType, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType, null)
                }
            )
        );

        Func<CallSite, Type, object, double[], TextPoint2D> target45 = Contructor.pSite47.Target;
        CallSite pSite30 = Contructor.pSite47;
        Type typeFromHandle4 = typeof(TextPoint2D);
        object arg5 = obj4;
        double[] array21 = new double[2];
        double[] array22 = array21;
        int num15 = 0;
        Contructor.pSite48 ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target46 = Contructor.pSite48.Target;
        CallSite pSite31 = Contructor.pSite48;
        Contructor.pSite49 ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "CenterEasting",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array22[num15] = target46(pSite31, Contructor.pSite49.Target(Contructor.pSite49, entity));
        double[] array23 = array21;
        int num16 = 1;
        Contructor.pSite4a ??= CallSite<Func<CallSite, object, double>>.Create(Binder.Convert(CSharpBinderFlags.None, typeof(double), typeof(Curve)));

        Func<CallSite, object, double> target47 = Contructor.pSite4a.Target;
        CallSite pSite4a = Contructor.pSite4a;
        Contructor.pSite4b ??= CallSite<Func<CallSite, object, object>>.Create(
            Binder.GetMember(
                CSharpBinderFlags.None,
                "CenterNorthing",
                typeof(Curve),
                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
            )
        );

        array23[num16] = target47(pSite4a, Contructor.pSite4b.Target(Contructor.pSite4b, entity));
        Center = target45(pSite30, typeFromHandle4, arg5, array21);
        while (DirStart < 0.0)
        {
            DirStart += 360.0;
        }

        while (DirStart >= 360.0)
        {
            DirStart -= 360.0;
        }

        while (DirEnd < 0.0)
        {
            DirStart += 360.0;
        }

        while (DirEnd >= 360.0)
        {
            DirStart -= 360.0;
        }

        Delta = DirEnd - DirStart;
    }

    [XmlAttribute("tangent")]
    public double Tangent { get; set; }

    [XmlAttribute("radius")]
    public double Radius { get; set; }

    [XmlAttribute("midOrd")]
    public double MidOrd { get; set; }

    [XmlAttribute("external")]
    public double External { get; set; }

    [XmlAttribute("dirStart")]
    public double DirStart { get; set; }

    [XmlAttribute("dirEnd")]
    public double DirEnd { get; set; }

    [XmlAttribute("delta")]
    public double Delta { get; set; }

    [XmlAttribute("chord")]
    public double Chord { get; set; }

    [XmlAttribute("rot")]
    public string Rot { get; set; }

    [XmlAttribute("crvType")]
    public string CrvType { get; set; }

    [XmlElement("HorizontallyCenter")]
    public TextPoint2D Center
    {
        get => _points[2];
        set => _points[2] = value;
    }

    [XmlElement("PI")]
    public TextPoint2D PI
    {
        get => _points[3];
        set => _points[3] = value;
    }

    public override double GetDirectionAtPoint(double station)
    {
        if (station == Length)
        {
            return DirEnd;
        }

        return station == 0.0 ? DirStart : DirStart + (Delta * station / Length);
    }

    [CompilerGenerated]
    private static class Contructor
    {
        public static CallSite<Func<CallSite, object, double>> pSite1;

        public static CallSite<Func<CallSite, object, double, object>> pSite10;

        public static CallSite<Func<CallSite, object, double, object>> pSite11;

        public static CallSite<Func<CallSite, object, object>> pSite12;

        public static CallSite<Func<CallSite, object, double>> pSite13;

        public static CallSite<Func<CallSite, object, double, object>> pSite14;

        public static CallSite<Func<CallSite, object, double, object>> pSite15;

        public static CallSite<Func<CallSite, object, object>> pSite16;

        public static CallSite<Func<CallSite, object, double>> pSite17;

        public static CallSite<Func<CallSite, object, object>> pSite18;

        public static CallSite<Func<CallSite, object, bool>> pSite19;

        public static CallSite<Func<CallSite, object, object>> pSite1a;

        public static CallSite<Func<CallSite, object, string>> pSite1b;

        public static CallSite<Func<CallSite, object, object>> pSite1c;

        public static CallSite<Func<CallSite, object, object>> pSite1d;

        public static CallSite<Func<CallSite, object, double>> pSite1e;

        public static CallSite<Func<CallSite, object, double, object>> pSite1f;

        public static CallSite<Func<CallSite, object, object>> pSite2;

        public static CallSite<Func<CallSite, object, object, object>> pSite20;

        public static CallSite<Func<CallSite, object, object>> pSite21;

        public static CallSite<Func<CallSite, object, object>> pSite22;

        public static CallSite<Func<CallSite, object, double[], object>> pSite23;

        public static CallSite<Func<CallSite, object, double>> pSite24;

        public static CallSite<Func<CallSite, object, object>> pSite25;

        public static CallSite<Func<CallSite, object, double>> pSite26;

        public static CallSite<Func<CallSite, object, object, object>> pSite27;

        public static CallSite<Func<CallSite, object, object>> pSite28;

        public static CallSite<Func<CallSite, object, double[], object>> pSite29;

        public static CallSite<Func<CallSite, object, double>> pSite2a;

        public static CallSite<Func<CallSite, object, object>> pSite2b;

        public static CallSite<Func<CallSite, object, double>> pSite2c;

        public static CallSite<Func<CallSite, object, object, object>> pSite2d;

        public static CallSite<Func<CallSite, object, object>> pSite2e;

        public static CallSite<Func<CallSite, object, double[], object>> pSite2f;

        public static CallSite<Func<CallSite, object, double>> pSite3;

        public static CallSite<Func<CallSite, object, double>> pSite30;

        public static CallSite<Func<CallSite, object, object>> pSite31;

        public static CallSite<Func<CallSite, object, double>> pSite32;

        public static CallSite<Func<CallSite, object, object, object>> pSite33;

        public static CallSite<Func<CallSite, object, object>> pSite34;

        public static CallSite<Func<CallSite, object, double[], object>> pSite35;

        public static CallSite<Func<CallSite, object, double>> pSite36;

        public static CallSite<Func<CallSite, object, double, object>> pSite37;

        public static CallSite<Func<CallSite, Type, object, double[], TextPoint2D>> pSite38;

        public static CallSite<Func<CallSite, object, double>> pSite39;

        public static CallSite<Func<CallSite, object, object>> pSite3a;

        public static CallSite<Func<CallSite, object, double>> pSite3b;

        public static CallSite<Func<CallSite, object, object>> pSite3c;

        public static CallSite<Func<CallSite, Type, object, double[], TextPoint2D>> pSite3d;

        public static CallSite<Func<CallSite, object, double>> pSite3e;

        public static CallSite<Func<CallSite, object, object>> pSite3f;

        public static CallSite<Func<CallSite, object, object>> pSite4;

        public static CallSite<Func<CallSite, object, double>> pSite40;

        public static CallSite<Func<CallSite, object, object>> pSite41;

        public static CallSite<Func<CallSite, Type, object, double[], TextPoint2D>> pSite42;

        public static CallSite<Func<CallSite, object, double>> pSite43;

        public static CallSite<Func<CallSite, object, object>> pSite44;

        public static CallSite<Func<CallSite, object, double>> pSite45;

        public static CallSite<Func<CallSite, object, object>> pSite46;

        public static CallSite<Func<CallSite, Type, object, double[], TextPoint2D>> pSite47;

        public static CallSite<Func<CallSite, object, double>> pSite48;

        public static CallSite<Func<CallSite, object, object>> pSite49;

        public static CallSite<Func<CallSite, object, double>> pSite4a;

        public static CallSite<Func<CallSite, object, object>> pSite4b;

        public static CallSite<Func<CallSite, object, double>> pSite5;

        public static CallSite<Func<CallSite, object, object>> pSite6;

        public static CallSite<Func<CallSite, object, double>> pSite7;

        public static CallSite<Func<CallSite, object, object>> pSite8;

        public static CallSite<Func<CallSite, object, double>> pSite9;

        public static CallSite<Func<CallSite, object, object>> pSitea;

        public static CallSite<Func<CallSite, object, double>> pSiteb;

        public static CallSite<Func<CallSite, object, double, object>> pSitec;

        public static CallSite<Func<CallSite, object, double, object>> pSited;

        public static CallSite<Func<CallSite, object, object>> pSitee;

        public static CallSite<Func<CallSite, object, double>> pSitef;
    }
}