public Example_19()
    {
        try {

            FileStream fos = new FileStream("Example_19.pdf", FileMode.Create);
            BufferedStream bos = new BufferedStream(fos);

            PDF pdf = new PDF( bos );

            FileStream fis = new FileStream( "Example_03.pdf", FileMode.Open );

            // FileInputStream fis = new FileInputStream( "PDF32000_2008.pdf" );

            BufferedStream bis = new BufferedStream( fis );
            List< PDFobj > objects = pdf.read(bis);
            for ( int j = 0; j < objects.Count; j++ ) {
                PDFobj obj = ( PDFobj ) objects[j];
                for ( int i = 0; i < obj.dict.Count; i++ ) {
                    Console.WriteLine(obj.dict[i]);
                }
                Console.WriteLine();
            }
            bis.Close();

            pdf.Flush();
            bos.Close();
        }
        catch ( Exception e ) {
            Console.WriteLine(e.StackTrace);
        }
    }

        public async Task ShouldNotFlushUnderlyingStreamIfReadOnly(bool underlyingCanSeek)
        {
            var underlying = new DelegateStream(
                canReadFunc: () => true,
                canWriteFunc: () => false,
                canSeekFunc: () => underlyingCanSeek,
                readFunc: (_, __, ___) => 123,
                writeFunc: (_, __, ___) =>
                {
                    throw new NotSupportedException();
                },
                seekFunc: (_, __) => 123L
            );

            var wrapper = new CallTrackingStream(underlying);

            var buffered = new BufferedStream(wrapper);
            buffered.ReadByte();

            buffered.Flush();
            Assert.Equal(0, wrapper.TimesCalled(nameof(wrapper.Flush)));

            await buffered.FlushAsync();
            Assert.Equal(0, wrapper.TimesCalled(nameof(wrapper.FlushAsync)));
        }

 public static void SetPositionToNegativeValue_Throws_ArgumentOutOfRangeException()
 {
     using (BufferedStream stream = new BufferedStream(new MemoryStream()))
     {
         Assert.Throws<ArgumentOutOfRangeException>(() => stream.Position = -1);
     }
 }

    public static void Main()
    {
        var bs = new BufferedStream(Console.OpenStandardInput());
        StreamReader reader = new StreamReader(bs);
        Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;

        string[] ss = reader.ReadLine().Split();
        double t = double.Parse(ss[0]);

        List<int> w = reader.ReadLine().Split().Select(x => int.Parse(x)).OrderBy(x => x).ToList();
        int res = max_cuts + 47, left = int.Parse(ss[1]);
        foreach (int q in w)
        {
            for (int i = 1; i <= max_cuts; i++)
            {
                double big = q / (double)i;
                var cut = w.Select(x => new {Count = Math.Ceiling(x / big), Length = x});
                if (cut.Min(y => y.Length / y.Count) >= t * big)
                {
                    double cnt = cut.Sum(y => y.Count - 1);
                    if (cnt < res) res = (int)cnt;
                }
            }
            left--;
        }
        Console.WriteLine(res);
    }

    /**
       	 * Writes a file from the contents of a String
       	 * @param filename The name of the file.
       	 * @return The String to write to the file.
       	 */
    public static void writeFile(string filename, string contents)
    {
        FileStream fs = null;
        BufferedStream bs = null;
        StreamWriter sw = null;

        try
        {
            fs = new FileStream(filename, FileMode.Open);

            // Here BufferedInputStream is added for fast writing.
            bs = new BufferedStream(fs);
            sw = new StreamWriter(bs);
            sw.Write(contents);

            // dispose all the resources after using them.
            fs.Close();
            bs.Close();
            sw.Close();
        }

        catch (FileNotFoundException e)
        {
            System.Console.WriteLine(e.ToString());
        }

        catch (IOException e)
        {
            System.Console.WriteLine(e.ToString());
        }
    }

 static void Main(string[] args)
 {
     using (FileStream fs = new FileStream(input, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
     {
         using (BufferedStream bs = new BufferedStream(fs))
         {
             using (StreamReader _in = new StreamReader(bs))
             {
                 using (StreamWriter _out = new StreamWriter(output))
                 {
                     string line;
                     while ((line = _in.ReadLine()) != null)
                     {
                         if (wholeWordOnly)
                         {
                             _out.WriteLine(Regex.Replace(line, @"\bstart\b", "finish"));
                         }
                         else
                         {
                             _out.WriteLine(line.Replace("start", "finish"));
                         }
                     }
                 }
             }
         }
     }
 }

 protected string invokeGetRequest(string requestUrl, string contentType)
 {
     string completeUrl = requestUrl;
     string responseString;
     try
     {
         HttpWebRequest request1 = WebRequest.Create(completeUrl) as HttpWebRequest;
         request1.ContentType = contentType;
         request1.Method = @"GET";
         HttpWebResponse httpWebResponse = (HttpWebResponse)request1.GetResponse();
         using (BufferedStream buffer = new BufferedStream(httpWebResponse.GetResponseStream()))
         {
             using (StreamReader reader = new StreamReader(buffer))
             {
                 responseString = reader.ReadToEnd();
             }
         }
         //StreamReader reader = new StreamReader(httpWebResponse.GetResponseStream());
         //string responseString = reader.ReadToEnd();
         return responseString;
     }
     catch (WebException ex)
     {
         //reading the custom messages sent by the server
         using (var reader = new StreamReader(ex.Response.GetResponseStream()))
         {
             return reader.ReadToEnd();
         }
     }
     catch (Exception ex)
     {
         return "Failed with exception message:" + ex.Message;
     }
 }

        public void TestBuffering(long length, int internalBufferCount, int clientBufferCount)
        {
            var random = new Random();
            var remoteData = new byte[length];
            random.NextBytes(remoteData);
            var buffer = new byte[clientBufferCount];
            var clientData = new List<byte>();
            Func<long, byte[], int> reader = (remoteOffset, buff) =>
            {
                int toRead = Math.Min(buff.Length, (int)(length - remoteOffset));
                Buffer.BlockCopy(remoteData, (int) remoteOffset, buff, 0, toRead);
                return  toRead;
            };
            var bufferedStream = new BufferedStream(length, reader, internalBufferCount);
            while (true)
            {
                int read = bufferedStream.Read(buffer, 0, buffer.Length);
                clientData.AddRange(buffer.Take(read));
                if(read==0)
                    break;
                
            }

            Assert.Equal(remoteData, clientData);
        }

        public async Task ShouldAlwaysFlushUnderlyingStreamIfWritable(bool underlyingCanRead, bool underlyingCanSeek)
        {
            var underlying = new DelegateStream(
                canReadFunc: () => underlyingCanRead,
                canWriteFunc: () => true,
                canSeekFunc: () => underlyingCanSeek,
                readFunc: (_, __, ___) => 123,
                writeFunc: (_, __, ___) => { },
                seekFunc: (_, __) => 123L
            );

            var wrapper = new CallTrackingStream(underlying);

            var buffered = new BufferedStream(wrapper);
            
            buffered.Flush();
            Assert.Equal(1, wrapper.TimesCalled(nameof(wrapper.Flush)));

            await buffered.FlushAsync();
            Assert.Equal(1, wrapper.TimesCalled(nameof(wrapper.FlushAsync)));

            buffered.WriteByte(0);
            
            buffered.Flush();
            Assert.Equal(2, wrapper.TimesCalled(nameof(wrapper.Flush)));

            await buffered.FlushAsync();
            Assert.Equal(2, wrapper.TimesCalled(nameof(wrapper.FlushAsync)));
        }

	public bool runTest()
	{
		Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
		int iCountErrors = 0;
		int iCountTestcases = 0;
		String strLoc = "Loc_000oo";
		String strValue = String.Empty;
		try
		{
			BinaryWriter sr2;
		    MemoryStream ms2;
			FileStream fs2;
			BufferedStream bs2;
			String filName = s_strTFAbbrev+"Test.tmp";
			if(File.Exists(filName))
				File.Delete(filName);			
			strLoc = "Loc_98hg7";
			ms2 = new MemoryStream();
			sr2 = new BinaryWriter(ms2);
			iCountTestcases++;
			if(sr2.BaseStream != ms2) {
				iCountErrors++;
				printerr( "Error_g57hb! Incorrect basestream");
			}
			sr2.Close();
			ms2 = new MemoryStream();
			bs2 = new BufferedStream(ms2);
			sr2 = new BinaryWriter(bs2);
			iCountTestcases++;
			if(sr2.BaseStream != bs2) {
				iCountErrors++;
				printerr( "Error_988hu! Incorrect basestream");
			}
			sr2.Close();
			fs2 = new FileStream(filName, FileMode.Create);
			sr2 = new BinaryWriter(fs2);
			iCountTestcases++;
			if(sr2.BaseStream != fs2) {
				iCountErrors++;
				printerr( "Error_29g87! Incorrect baseStream");
			}
			sr2.Close();
			if(File.Exists(filName))
				File.Delete(filName);
		} catch (Exception exc_general ) {
			++iCountErrors;
			Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy!  strLoc=="+ strLoc +", exc_general=="+exc_general.ToString());
		}
		if ( iCountErrors == 0 )
		{
			Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
			return true;
		}
		else
		{
			Console.WriteLine("FAiL! "+s_strTFName+" ,iCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
			return false;
		}
	}

		private void Connect()
		{
			socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
			{
				SendTimeout = SendTimeout,
				ReceiveTimeout = ReceiveTimeout
			};
			try
			{
                if (ConnectTimeout == 0)
                {
                    socket.Connect(Host, Port);
                }
                else
                {
                    var connectResult = socket.BeginConnect(Host, Port, null, null);
                    connectResult.AsyncWaitHandle.WaitOne(ConnectTimeout, true);
                }

				if (!socket.Connected)
				{
					socket.Close();
					socket = null;
					return;
				}
				Bstream = new BufferedStream(new NetworkStream(socket), 16 * 1024);

				if (Password != null)
					SendExpectSuccess(Commands.Auth, Password.ToUtf8Bytes());

				db = 0;
				var ipEndpoint = socket.LocalEndPoint as IPEndPoint;
				clientPort = ipEndpoint != null ? ipEndpoint.Port : -1;
				lastCommand = null;
				lastSocketException = null;
				LastConnectedAtTimestamp = Stopwatch.GetTimestamp();

				if (isPreVersion1_26 == null)
				{
					isPreVersion1_26 = this.ServerVersion.CompareTo("1.2.6") <= 0;
				}

                if (ConnectionFilter != null)
                {
                    ConnectionFilter(this);
                }
			}
			catch (SocketException ex)
			{
                if (socket != null)
                    socket.Close();
                socket = null;

				HadExceptions = true;
				var throwEx = new RedisException("could not connect to redis Instance at " + Host + ":" + Port, ex);
				log.Error(throwEx.Message, ex);
				throw throwEx;
			}
		}

 public static void StreamThroughWaveFile(string sFileName,IReadWaveData objCallback)
 {
     using (FileStream fs = new FileStream(sFileName,FileMode.Open,FileAccess.Read))
     using (BufferedStream bs = new BufferedStream(fs, nBufferSize))
     using (BinaryReader r = new BinaryReader(bs))
     {
         StreamThroughWaveFile(r, objCallback);
     }
 }

 private static void StartWavAnalyze(string strFileName,long nLength)
 {
     using (FileStream fs = new FileStream(strFileName,FileMode.Open,FileAccess.Read))
     using (BufferedStream bs = new BufferedStream(fs,nBufferSize))
     using (BinaryReader r = new BinaryReader(bs))
     {
         StartWavAnalyze(r,nLength);
     }
 }

    public Example_01()
    {
        FileStream fos = new FileStream("Example_01.pdf", FileMode.Create);
        BufferedStream bos = new BufferedStream(fos);

        PDF pdf = new PDF(bos);
        pdf.setCompressor(Compressor.ORIGINAL_ZLIB);

        Page page = new Page(pdf, Letter.PORTRAIT);

        Box flag = new Box();
        flag.SetPosition(100.0, 100.0);
        flag.SetSize(190.0, 100.0);
        flag.SetColor(RGB.WHITE);
        flag.DrawOn(page);

        double sw = 7.69;   // stripe width
        Line stripe = new Line(0.0, sw/2, 190.0, sw/2);
        stripe.SetWidth(sw);
        stripe.SetColor(RGB.OLD_GLORY_RED);
        for (int row = 0; row < 7; row++) {
            stripe.PlaceIn(flag, 0.0, row * 2 * sw);
            stripe.DrawOn(page);
        }

        Box union = new Box();
        union.SetSize(76.0, 53.85);
        union.SetColor(RGB.OLD_GLORY_BLUE);
        union.SetFillShape(true);
        union.PlaceIn(flag, 0.0, 0.0);
        union.DrawOn(page);

        double h_si = 12.6; // horizontal star interval
        double v_si = 10.8; // vertical star interval
        Point star = new Point(h_si/2, v_si/2);
        star.SetShape(Point.STAR);
        star.SetRadius(3.0);
        star.SetColor(RGB.WHITE);
        star.SetFillShape(true);

        for (int row = 0; row < 6; row++) {
            for (int col = 0; col < 5; col++) {
                star.PlaceIn(union, row * h_si, col * v_si);
                star.DrawOn(page);
            }
        }
        star.SetPosition(h_si, v_si);
        for (int row = 0; row < 5; row++) {
            for (int col = 0; col < 4; col++) {
                star.PlaceIn(union, row * h_si, col * v_si);
                star.DrawOn(page);
            }
        }

        pdf.Flush();
        bos.Close();
    }

    public Example_04()
    {
        String fileName = "data/happy-new-year.txt";

        FileStream fos = new FileStream("Example_04.pdf", FileMode.Create);
        BufferedStream bos = new BufferedStream(fos);

        PDF pdf = new PDF(bos);
        pdf.setCompressor(Compressor.ORIGINAL_ZLIB);

        Font f1 = new Font(
                pdf,
                "AdobeMingStd-Light",       // Chinese (Traditional) font
                CodePage.UNICODE);
        Font f2 = new Font(
                pdf,
                "AdobeSongStd-Light",       // Chinese (Simplified) font
                CodePage.UNICODE);
        Font f3 = new Font(
                pdf,
                "KozMinProVI-Regular",      // Japanese font
                CodePage.UNICODE);
        Font f4 = new Font(
                pdf,
                "AdobeMyungjoStd-Medium",   // Korean font
                CodePage.UNICODE);

        Page page = new Page(pdf, Letter.PORTRAIT);

        f1.SetSize(14);
        f2.SetSize(14);
        f3.SetSize(14);
        f4.SetSize(14);

        double x_pos = 100.0;
        double y_pos = 20.0;
        StreamReader reader = new StreamReader(
                new FileStream(fileName, FileMode.Open));
        TextLine text = new TextLine(f1);
        String line = null;
        while ((line = reader.ReadLine()) != null) {
            if (line.IndexOf("Simplified") != -1) {
                text.SetFont(f2);
            } else if (line.IndexOf("Japanese") != -1) {
                text.SetFont(f3);
            } else if (line.IndexOf("Korean") != -1) {
                text.SetFont(f4);
            }
            text.SetText(line);
            text.SetPosition(x_pos, y_pos += 24);
            text.DrawOn(page);
        }
        reader.Close();

        pdf.Flush();
        bos.Close();
    }

    public List<string> GetAllData()
    {
        string line = "";
        string input_file = "./Saved Data/characters.xml";
        List<string> keyList = new List<string>();
        List<string> elemList = new List<string>();
        UnicodeEncoding encoding = new UnicodeEncoding();
        byte[] key = null;
        RijndaelManaged RMCrypto = new RijndaelManaged();
        string tagID;
        string tagIDend;
        int indexStart = 0;
        int indexEnd = 0;

        key = encoding.GetBytes(Data_Handler_Key.keyvalue);
        FileStream decrypted_file = new FileStream(input_file, FileMode.Open);
        CryptoStream cryptography_stream = new CryptoStream(decrypted_file, RMCrypto.CreateDecryptor(key, key), CryptoStreamMode.Read);
        using (MemoryStream msDecrypt = new MemoryStream())
        {
            using (BufferedStream readBuffer = new BufferedStream(cryptography_stream))
            using (StreamReader srDecrypt = new StreamReader(readBuffer))
            {
                    while ((line = srDecrypt.ReadLine()) != null)
                    {
                        elemList.Add(line);
                    }
            }
        }
        cryptography_stream.Close();
        decrypted_file.Close();
        tagID = "<id>" + Character_Info.id + "</id>";
        tagIDend = "<idend>" + Character_Info.id + "</idend>";
        int i = 0;
        foreach(var content in elemList)
        {
            if(content == tagID)
            {
                indexStart = i;
            }

            if(content == tagIDend)
            {
                indexEnd = i;
            }
            i++;
        }
        if (indexStart != indexEnd)
        {
            elemList.RemoveRange(indexStart, indexEnd - indexStart);
        }
        elemList.Remove("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
        elemList.Remove("<savedcharacters>");
        elemList.Remove("</savedcharacters>");
        return elemList;
    }

    public static void Main()
    {
        var bs = new BufferedStream(Console.OpenStandardInput());
        StreamReader reader = new StreamReader(bs);

        string[] ss = reader.ReadLine().Split();
        int n = int.Parse(ss[0]), k = int.Parse(ss[1]);
        List<int> a = reader.ReadLine().Split().Select(x => int.Parse(x) - 1).ToList();

        var cycles = Enumerable.Range(0, n).Select(x => new List<List<int>>()).ToArray();
        bool[] seen = new bool[n];
        foreach (int i in Enumerable.Range(0, n))
            if (!seen[i])
        {
            List<int> cyc = new List<int> ();
            int u = i;
            do {
                cyc.Add(u);
                seen[u] = true;
                u = a[u];
            } while (u != i);
            cycles[cyc.Count].Add(cyc);
        }

        Dictionary<int, int> pow = factor(k).ToDictionary(x => x.Prime, x => x.Power);
        List<int> res = Enumerable.Repeat(-1, n).ToList();
        foreach (var group in cycles.Where(x => x.Count > 0))
        {
            int len = group.First().Count;
            int need = len == 1 ?
                gcd(k, group.Count) : // we want to avoid self-loops
                factor(len)
                .Where(f => pow.ContainsKey(f.Prime))
                .Select(f => pow[f.Prime])
                .Aggregate(1, (x, y) => x * y);//multiply everything

            if (group.Count % need == 0)
                for (int i = 0; i < group.Count; i += need)
                {
                    List<int> cyc = new List<int> ();
                    foreach (int l in Enumerable.Range(0, len))
                        foreach (int j in Enumerable.Range(0, need))
                            cyc.Add(group[i + j][l]);

                    int move = inverse(k / need % len, len);
                    foreach (int j in Enumerable.Range(0, cyc.Count))
                        res[cyc[j]] = cyc[(j + move) % cyc.Count];
                }
        }

        if (res.Any(x => x == -1))
            Console.WriteLine("Impossible");
        else
            Console.WriteLine(string.Join(" ", res.Select(x => x + 1)));
    }

    public static void Main()
    {
        var bs = new BufferedStream(Console.OpenStandardInput());
        StreamReader reader = new StreamReader(bs);

        int n = int.Parse(reader.ReadLine());
        List<int> a = reader.ReadLine().Split().Select(x => int.Parse(x))
            .OrderByDescending(x => x).ToList();

        Console.WriteLine(Enumerable.Range(0, n - 1).Max(i => i + a[i] + 2));
    }

 public static void SetLength_NegativeValue()
 {
     using (MemoryStream underlying = new MemoryStream())
     using (BufferedStream stream = new BufferedStream(underlying))
     {
         Assert.Throws<ArgumentOutOfRangeException>(() => stream.SetLength(-1));
         stream.SetLength(1);
         Assert.Equal(1, underlying.Length);
         Assert.Equal(1, stream.Length);
     }
 }

 public static void Write_Arguments()
 {
     using (BufferedStream stream = new BufferedStream(new MemoryStream()))
     {
         byte[] array = new byte[10];
         Assert.Throws<ArgumentNullException>("array", () => stream.Write(null, 1, 1));
         Assert.Throws<ArgumentOutOfRangeException>(() => stream.Write(array, -1, 1));
         Assert.Throws<ArgumentOutOfRangeException>(() => stream.Write(array, 1, -1));
         Assert.Throws<ArgumentException>(() => stream.Write(array, 9, 2));
     }
 }