using Sprache;
using System.Collections.Generic;

namespace SphracheTest
{
    public abstract class Node : IPositionAware<Node>
    {
        public abstract IEnumerable<Node> Children { get; }

        public Position? StartPos { get; private set; }

        public int Length { get; private set; }

        public Node SetPos(Position startPos, int length)
        {
            StartPos = startPos;
            Length = length;
            return this;
        }
    }
}

using Sprache;
using System;
using System.Collections.Generic;

namespace SphracheTest
{
    public class Literal<T> : Node, IPositionAware<Literal<T>>
    {
        public T Value { get; }

        public Literal(T value) => Value = value;

        public override IEnumerable<Node> Children => Array.Empty<Node>();

        public override string? ToString() => Value?.ToString();

        Literal<T> IPositionAware<Literal<T>>.SetPos(Position startPos, int length) => (Literal<T>)SetPos(startPos, length);
    }
}

using Sprache;
using System;
using System.Collections.Generic;

namespace SphracheTest
{
    public enum BinaryOperator
    {
        Plus,
        Subtract,
    }

    public class BinaryExpression : Node, IPositionAware<BinaryExpression>
    {
        public override IEnumerable<Node> Children => new Node[] { Left, Right };

        public BinaryOperator Operator { get; }

        public Node Left { get; }

        public Node Right { get; }

        public BinaryExpression(BinaryOperator op, Node lhs, Node rhs)
        {
            Operator = op;
            Left = lhs;
            Right = rhs;
        }

        public override string? ToString() => string.Join(GetOperatorString(), Left, Right);

        private string GetOperatorString() => Operator switch
        {
            BinaryOperator.Plus => " + ",
            BinaryOperator.Subtract => " - ",
            _ => throw new ArgumentException("Invalid operator", nameof(Operator)),
        };

        BinaryExpression IPositionAware<BinaryExpression>.SetPos(Position startPos, int length) => (BinaryExpression)SetPos(startPos, length);
    }
}

using System.Text;

namespace SphracheTest
{
    public static class NodeExtension
    {
        public static string ToTreeForm(this Node node) => node.ToTreeFormImpl(new StringBuilder().AppendTreeNode(node), prefix: string.Empty).ToString();

        private static StringBuilder ToTreeFormImpl(this Node node, StringBuilder acc, string prefix)
        {
            var iter = node.Children.GetEnumerator();
            if (!iter.MoveNext())
                return acc;
            while (true)
            {
                var child = iter.Current;
                acc.Append(prefix);
                if (iter.MoveNext())
                {
                    child.ToTreeFormImpl(acc.Append("├─").AppendTreeNode(child), prefix + "│ ");
                }
                else
                {
                    return child.ToTreeFormImpl(acc.Append("└─").AppendTreeNode(child), prefix + "  ");
                }
            }
        }

        private static StringBuilder AppendTreeNode(this StringBuilder acc, Node node)
        {
            acc.Append(node.ToString());
            if (node.StartPos != null)
            {
                acc
                    .Append(" ( Pos ")
                    .Append(node.StartPos.Pos)
                    .Append(", Line ")
                    .Append(node.StartPos.Line)
                    .Append(", Column ")
                    .Append(node.StartPos.Column)
                    .Append(", Length ")
                    .Append(node.Length)
                    .Append(" )");
            }
            return acc.AppendLine();
        }
    }
}

using Sprache;
using System;

namespace SphracheTest
{
    static class Program
    {
        static readonly Parser<Node> parserInt =
            (from n in Parse.Number select new Literal<int>(int.Parse(n)))
            .Positioned()
            .Token();

        static readonly Parser<BinaryOperator> parserOperatorPlus =
            Parse.Char('+').Return(BinaryOperator.Plus);

        static readonly Parser<BinaryOperator> parserOperatorSubtract =
            Parse.Char('-').Return(BinaryOperator.Subtract);

        static readonly Parser<BinaryOperator> parserOperator =
            parserOperatorPlus.XOr(parserOperatorSubtract).Token();

        static readonly Parser<Node> parserExpression =
            Parse.ChainOperator(parserOperator, parserInt, (op, lhs, rhs) => new BinaryExpression(op, lhs, rhs))
            .Positioned(); // only work for top-level

        static void Main(string[] args)
        {
            Console.WriteLine(parserExpression.Parse(Console.ReadLine()).ToTreeForm());
        }
    }
}