[NitraMessage, StructuralEquality]
  public struct NSpan : IComparable[NSpan]
  {
    public StartPos : int;
    public EndPos   : int;
    public Length   : int { get { EndPos - StartPos }}
    
    public IsEmpty : bool
    {
      get { StartPos == EndPos }
    }
    
    public IntersectsWith(pos : int)              : bool { pos <= EndPos && pos >= StartPos }
    public IntersectsWith(start : int, end : int) : bool { start <= EndPos && end >= StartPos }
    public IntersectsWith(other : NSpan)          : bool { IntersectsWith(other.StartPos, other.EndPos) }
    public IntersectsWith(other : Range)          : bool { IntersectsWith(other.Span) }
    public IntersectsWith(other : Location)       : bool { IntersectsWith(other.Range) }
    
    public override ToString() : string { StartPos + ", " + EndPos }
    
    public CompareTo(other : NSpan) : int
    {
      def result = StartPos.CompareTo(other.StartPos);
      if (result == 0)
        EndPos.CompareTo(other.EndPos)
      else
        result
    }
  }

public struct NSpan : IComparable<NSpan>, IEquatable<NSpan>, IStructuralEquatable
{
  public readonly int StartPos;

  public readonly int EndPos;

  public int Length
  {
    get
    {
      return checked(this.EndPos - this.StartPos);
    }
  }

  public bool IsEmpty
  {
    get
    {
      return this.StartPos == this.EndPos;
    }
  }

  public short MsgId
  {
    get
    {
      return 109;
    }
  }

  public int GetHashCode(IEqualityComparer _comparer)
  {
    return this.GetHashCode();
  }

  public bool Equals(object other, IEqualityComparer _comparer)
  {
    return this.Equals(other);
  }

  public static bool operator !=(NSpan first, NSpan second)
  {
    return !(first == second);
  }

  public static bool operator ==(NSpan first, NSpan second)
  {
    return first.Equals(second);
  }

  public override int GetHashCode()
  {
    int hash = 0;
    hash += this.StartPos;
    hash += hash << 10;
    hash ^= hash >> 6;
    hash += this.EndPos;
    hash += hash << 10;
    return hash ^ hash >> 6;
  }

  public override bool Equals(object other)
  {
    bool arg_2E_0;
    if (!(other is NSpan))
    {
      arg_2E_0 = false;
    }
    else
    {
      NSpan x = (NSpan)other;
      arg_2E_0 = this.EqualsImpl(x);
    }
    return arg_2E_0;
  }

  public bool Equals(NSpan other)
  {
    return this.EqualsImpl(other);
  }

  public bool IntersectsWith(int pos)
  {
    return pos <= this.EndPos && pos >= this.StartPos;
  }

  public bool IntersectsWith(int start, int end)
  {
    return start <= this.EndPos && end >= this.StartPos;
  }

  public bool IntersectsWith(NSpan other)
  {
    return this.IntersectsWith(other.StartPos, other.EndPos);
  }

  public bool IntersectsWith(Range other)
  {
    return this.IntersectsWith(other.Span);
  }

  public bool IntersectsWith(Location other)
  {
    return this.IntersectsWith(other.Range);
  }

  public override string ToString()
  {
    return this.StartPos.ToString() + ", " + this.EndPos.ToString();
  }

  public int CompareTo(NSpan other)
  {
    int result = this.StartPos.CompareTo(other.StartPos);
    return (result != 0) ? result : this.EndPos.CompareTo(other.EndPos);
  }

  private bool EqualsImpl(NSpan other)
  {
    return this.EndPos == other.EndPos && this.StartPos == other.StartPos;
  }

  public void Serialize(BinaryWriter writer)
  {
    writer.Write(this.StartPos);
    writer.Write(this.EndPos);
  }

  public static NSpan Deserialize(BinaryReader reader)
  {
    int num = reader.ReadInt32();
    int arg_10_0 = num;
    int endPos = reader.ReadInt32();
    return new NSpan(arg_10_0, endPos);
  }

  [RecordCtor]
  public NSpan([MappedMember("StartPos")] int startPos, [MappedMember("EndPos")] int endPos)
  {
    this.StartPos = startPos;
    this.EndPos = endPos;
  }
}