using System;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;

public class KSubstring
{
    class TreapNode
    {
        public static TreapNode Insert(TreapNode root, long val)
        {
            TreapNode left, right;
            Split(root, val, out left, out right);
            return Merge(Merge(left, new TreapNode(val)), right);
        }

        public TreapNode(long val)
        {
            this.val = val;
            pri = rnd.Next();
        }

        public static long FindLessEqDiff(TreapNode root, long x)
        {
            if (root == null)
                return long.MaxValue;
            if (root.val == x)
                return 0;
            if (root.val < x)
            {
                long z = FindLessEqDiff(root.right, x);
                return z == long.MaxValue ? root.val - x : z;
            }
            else
                return FindLessEqDiff(root.left, x);
        }

        public static long FindGreaterEqDiff(TreapNode root, long x)
        {
            if (root == null)
                return long.MaxValue;
            if (root.val == x)
                return 0;
            if (root.val < x)
                return FindGreaterEqDiff(root.right, x);
            else
            {
                long z = FindGreaterEqDiff(root.left, x);
                return z == long.MaxValue ? root.val - x : z;
            }
        }

        private static void Split(TreapNode root, long val, out TreapNode left, out TreapNode right)
        {
            if (root == null)
            {
                left = null;
                right = null;
            }
            else if (root.val < val)
            {
                Split(root.right, val, out root.right, out right);
                left = root;
            }
            else
            {
                Split(root.left, val, out left, out root.left);
                right = root;
            }
        }

        private static TreapNode Merge(TreapNode left, TreapNode right)
        {
            if (left == null)
                return right;
            else if (right == null)
                return left;
            else if (left.pri >= right.pri)
            {
                left.right = Merge(left.right, right);
                return left;
            }
            else
            {
                right.left = Merge(left, right.left);
                return right;
            }
        }

        private TreapNode left, right;
        private long val;
        private int pri;
        private static Random rnd = new Random();
    }

    public int[] maxSubstring(int A0, int X, int Y, int M, int n)
    {
        long[] A = new long[n];
        A[0] = A0;
        for (int i = 1; i < n; i++)
            A[i] = (A[i - 1] * X + Y) % M;

        long minDiff = long.MaxValue;
        int maxLen = 0;
        for (int len = 1; 2 * len <= n; len++)
        {
            long[] sums = new long[n];
            for (int i = 0; i < n; i++)
            {
                if (i < len)
                    sums[len - 1] += A[i];
                else
                    sums[i] = sums[i - 1] + (A[i] - A[i - len]);
            }

            TreapNode root = null;
            for (int fst = len - 1, snd = 2 * len - 1; snd < n; fst++, snd++)
            {
                root = TreapNode.Insert(root, sums[fst]);
                long target = sums[snd];
                long nval = Math.Min(
                    Math.Abs(TreapNode.FindLessEqDiff(root, target)),
                    Math.Abs(TreapNode.FindGreaterEqDiff(root, target))
                );
                if (nval <= minDiff)
                {
                    maxLen = len;
                    minDiff = nval;
                }
            }
        }

        return new int[] { maxLen, (int) minDiff };
    }
}