1 #[macro_use]
2 extern crate proptest;
3 extern crate ropey;
4
5 use proptest::collection::vec;
6 use proptest::test_runner::Config;
7 use ropey::{
8 str_utils::{
9 byte_to_char_idx, byte_to_line_idx, char_to_byte_idx, char_to_line_idx, line_to_byte_idx,
10 },
11 Rope,
12 };
13
string_insert(text: &mut String, char_idx: usize, text_ins: &str)14 fn string_insert(text: &mut String, char_idx: usize, text_ins: &str) {
15 let byte_idx = char_to_byte_idx(text, char_idx);
16 text.insert_str(byte_idx, text_ins);
17 }
18
string_remove(text: &mut String, char_start: usize, char_end: usize)19 fn string_remove(text: &mut String, char_start: usize, char_end: usize) {
20 let byte_start = char_to_byte_idx(text, char_start);
21 let byte_end = char_to_byte_idx(text, char_end);
22 let text_r = text.split_off(byte_end);
23 text.truncate(byte_start);
24 text.push_str(&text_r);
25 }
26
string_slice(text: &str, char_start: usize, char_end: usize) -> &str27 fn string_slice(text: &str, char_start: usize, char_end: usize) -> &str {
28 let byte_start = char_to_byte_idx(text, char_start);
29 let text = &text[byte_start..];
30 let byte_end = char_to_byte_idx(text, char_end - char_start);
31 &text[..byte_end]
32 }
33
34 /// A slower, but easy-to-verify, byte->line index converter.
35 ///
36 /// We use this to verify the faster-but-more-complex functions in
37 /// Ropey.
38 ///
39 /// Note: counts the number of _complete_ line endings before the given byte.
40 /// For example, giving the byte index for the LF in a CRLF pair does not
41 /// count the CR as a line ending, since we're not past the complete line
42 /// ending.
byte_to_line_index_slow(text: &str, byte_idx: usize) -> usize43 fn byte_to_line_index_slow(text: &str, byte_idx: usize) -> usize {
44 assert!(byte_idx <= text.len());
45
46 let mut byte_itr = text.bytes();
47 let mut i = 0;
48 let mut line_count = 0;
49
50 while let Some(byte) = byte_itr.next() {
51 if i >= byte_idx {
52 break;
53 }
54
55 match byte {
56 0x0A | 0x0B | 0x0C => {
57 line_count += 1;
58 }
59 0x0D => {
60 // Check for a following LF. By cloning the itr, we're
61 // peeking without actually stepping the original itr.
62 if let Some(0x0A) = byte_itr.clone().next() {
63 // Do nothing. The CRLF will be properly counted
64 // on the next iteration if the LF is behind
65 // byte_idx.
66 } else {
67 // There's no following LF, so the stand-alone CR is a
68 // line ending itself.
69 line_count += 1;
70 }
71 }
72 0xC2 => {
73 if (i + 1) < byte_idx {
74 i += 1;
75 if let Some(0x85) = byte_itr.next() {
76 line_count += 1;
77 }
78 }
79 }
80 0xE2 => {
81 if (i + 2) < byte_idx {
82 i += 2;
83 let byte2 = byte_itr.next().unwrap();
84 let byte3 = byte_itr.next().unwrap() >> 1;
85 if byte2 == 0x80 && byte3 == 0x54 {
86 line_count += 1;
87 }
88 }
89 }
90 _ => {}
91 }
92
93 i += 1;
94 }
95
96 line_count
97 }
98
99 /// A slower, but easy-to-verify, line->byte index converter.
100 ///
101 /// We use this to verify the faster-but-more-complex functions in
102 /// Ropey.
line_to_byte_index_slow(text: &str, line_idx: usize) -> usize103 fn line_to_byte_index_slow(text: &str, line_idx: usize) -> usize {
104 assert!(line_idx <= byte_to_line_idx(text, text.len()));
105
106 let mut byte_itr = text.bytes();
107 let mut i = 0;
108 let mut line_count = 0;
109
110 while let Some(byte) = byte_itr.next() {
111 if line_count == line_idx {
112 break;
113 }
114
115 match byte {
116 0x0A | 0x0B | 0x0C => {
117 line_count += 1;
118 }
119 0x0D => {
120 // Check for a following LF. By cloning the itr, we're
121 // peeking without actually stepping the original itr.
122 if let Some(0x0A) = byte_itr.clone().next() {
123 // Skip the LF, since it's part of the CRLF
124 // pair.
125 i += 1;
126 byte_itr.next();
127 }
128 line_count += 1;
129 }
130 0xC2 => {
131 i += 1;
132 if let Some(0x85) = byte_itr.next() {
133 line_count += 1;
134 }
135 }
136 0xE2 => {
137 i += 2;
138 let byte2 = byte_itr.next().unwrap();
139 let byte3 = byte_itr.next().unwrap() >> 1;
140 if byte2 == 0x80 && byte3 == 0x54 {
141 line_count += 1;
142 }
143 }
144 _ => {}
145 }
146
147 i += 1;
148 }
149
150 i
151 }
152
153 //===========================================================================
154
155 proptest! {
156 #![proptest_config(Config::with_cases(512))]
157
158 #[test]
159 fn pt_from_str(ref text in "\\PC*\\PC*\\PC*") {
160 let rope = Rope::from_str(&text);
161
162 rope.assert_integrity();
163 rope.assert_invariants();
164
165 assert_eq!(rope, text.as_str());
166 }
167
168 #[test]
169 fn pt_from_str_crlf(ref text in "[\\u{000A}\\u{000D}]*\\u{000A}\\u{000D}]*\\u{000A}\\u{000D}]*") {
170 let rope = Rope::from_str(&text);
171
172 rope.assert_integrity();
173 rope.assert_invariants();
174
175 assert_eq!(rope, text.as_str());
176 }
177
178 #[test]
179 fn pt_insert(char_idx in 0usize..(CHAR_LEN+1), ref ins_text in "\\PC*") {
180 let mut rope = Rope::from_str(TEXT);
181 let mut text = String::from(TEXT);
182
183 let len = rope.len_chars();
184 rope.insert(char_idx % (len + 1), &ins_text);
185 string_insert(&mut text, char_idx % (len + 1), &ins_text);
186
187 rope.assert_integrity();
188 rope.assert_invariants();
189
190 assert_eq!(rope, text);
191 }
192
193 #[test]
194 fn pt_remove(range in (0usize..(CHAR_LEN+1), 0usize..(CHAR_LEN+1))) {
195 let mut rope = Rope::from_str(TEXT);
196 let mut text = String::from(TEXT);
197
198 let mut idx1 = range.0 % (rope.len_chars() + 1);
199 let mut idx2 = range.1 % (rope.len_chars() + 1);
200 if idx1 > idx2 {
201 std::mem::swap(&mut idx1, &mut idx2)
202 };
203
204 rope.remove(idx1..idx2);
205 string_remove(&mut text, idx1, idx2);
206
207 rope.assert_integrity();
208 rope.assert_invariants();
209
210 assert_eq!(rope, text);
211 }
212
213 #[test]
214 fn pt_split_off_and_append(mut idx in 0usize..(CHAR_LEN+1)) {
215 let mut rope = Rope::from_str(TEXT);
216
217 idx %= rope.len_chars() + 1;
218
219 let rope2 = rope.split_off(idx);
220
221 rope.assert_integrity();
222 rope.assert_invariants();
223 rope2.assert_integrity();
224 rope2.assert_invariants();
225
226 rope.append(rope2);
227
228 rope.assert_integrity();
229 rope.assert_invariants();
230
231 assert_eq!(rope, TEXT);
232 }
233
234 #[test]
235 fn pt_shrink_to_fit_01(ref char_idxs in vec(0usize..1000000, 0..1000)) {
236 let mut rope = Rope::new();
237
238 for idx in char_idxs.iter() {
239 let len = rope.len_chars();
240 rope.insert(idx % (len + 1), "Hello world!")
241 }
242
243 let capacity_before = rope.capacity();
244 let rope_clone = rope.clone();
245
246 rope.shrink_to_fit();
247
248 rope.assert_integrity();
249 rope.assert_invariants();
250 assert_eq!(rope, rope_clone);
251
252 let max_leaf_bytes = 1024 - 33;
253 assert!((rope.capacity() - rope.len_bytes()) <= max_leaf_bytes);
254 assert!(rope.capacity() <= capacity_before);
255 }
256
257 #[test]
258 fn pt_shrink_to_fit_02(ref char_idxs in vec(0usize..1000000, 0..1000)) {
259 let mut rope = Rope::new();
260 let ins_text = "AT̴̷͚͖̜͈̪͎͔̝̫̦̹͔̻̮͂ͬͬ̌ͣ̿ͤ͌ͥ͑̀̂ͬ̚͘͜͞ô̵͚̤̯̹͖̅̌̈́̑̏̕͘͝A";
261
262 for idx in char_idxs.iter() {
263 let len = rope.len_chars();
264 rope.insert(idx % (len + 1), ins_text);
265 }
266
267 let rope_clone = rope.clone();
268
269 rope.shrink_to_fit();
270
271 rope.assert_integrity();
272 rope.assert_invariants();
273 assert_eq!(rope, rope_clone);
274
275 let max_leaf_bytes = 1024 - 33;
276 let max_diff = max_leaf_bytes + ((rope.len_bytes() / max_leaf_bytes) * ins_text.len());
277
278 assert!((rope.capacity() - rope.len_bytes()) <= max_diff);
279 }
280
281 #[test]
282 fn pt_chunk_at_byte(ref text in "\\PC*\\n?\\PC*\\n?\\PC*") {
283 let r = Rope::from_str(text);
284 let mut t = &text[..];
285
286 let mut last_chunk = "";
287 for i in 0..r.len_bytes() {
288 let (chunk, b, c, l) = r.chunk_at_byte(i);
289 assert_eq!(c, byte_to_char_idx(text, b));
290 assert_eq!(l, byte_to_line_idx(text, b));
291 if chunk != last_chunk {
292 assert_eq!(chunk, &t[..chunk.len()]);
293 t = &t[chunk.len()..];
294 last_chunk = chunk;
295 }
296
297 let c1 = {
298 let i2 = byte_to_char_idx(text, i);
299 text.chars().nth(i2).unwrap()
300 };
301 let c2 = {
302 let i2 = i - b;
303 let i3 = byte_to_char_idx(chunk, i2);
304 chunk.chars().nth(i3).unwrap()
305 };
306 assert_eq!(c1, c2);
307 }
308 assert_eq!(t.len(), 0);
309 }
310
311 #[test]
312 fn pt_chunk_at_char(ref text in "\\PC*\\n?\\PC*\\n?\\PC*") {
313 let r = Rope::from_str(text);
314 let mut t = &text[..];
315
316 let mut last_chunk = "";
317 for i in 0..r.len_chars() {
318 let (chunk, b, c, l) = r.chunk_at_char(i);
319 assert_eq!(b, char_to_byte_idx(text, c));
320 assert_eq!(l, char_to_line_idx(text, c));
321 if chunk != last_chunk {
322 assert_eq!(chunk, &t[..chunk.len()]);
323 t = &t[chunk.len()..];
324 last_chunk = chunk;
325 }
326
327 let c1 = text.chars().nth(i).unwrap();
328 let c2 = {
329 let i2 = i - c;
330 chunk.chars().nth(i2).unwrap()
331 };
332 assert_eq!(c1, c2);
333 }
334 assert_eq!(t.len(), 0);
335 }
336
337 #[test]
338 fn pt_chunk_at_line_break(ref text in "\\PC*\\n?\\PC*\\n?\\PC*") {
339 let r = Rope::from_str(&text);
340
341 // First chunk
342 {
343 let (chunk, b, c, l) = r.chunk_at_line_break(0);
344 assert_eq!(chunk, &text[..chunk.len()]);
345 assert_eq!(b, 0);
346 assert_eq!(c, 0);
347 assert_eq!(l, 0);
348 }
349
350 // Middle chunks
351 for i in 1..r.len_lines() {
352 let (chunk, b, c, l) = r.chunk_at_line_break(i);
353 assert_eq!(chunk, &text[b..(b + chunk.len())]);
354 assert_eq!(c, byte_to_char_idx(&text, b));
355 assert_eq!(l, byte_to_line_idx(&text, b));
356 assert!(l < i);
357 assert!(i <= byte_to_line_idx(&text, b + chunk.len()));
358 }
359
360 // Last chunk
361 {
362 let (chunk, b, c, l) = r.chunk_at_line_break(r.len_lines());
363 assert_eq!(chunk, &text[(text.len() - chunk.len())..]);
364 assert_eq!(chunk, &text[b..]);
365 assert_eq!(c, byte_to_char_idx(&text, b));
366 assert_eq!(l, byte_to_line_idx(&text, b));
367 }
368 }
369
370 #[test]
371 fn pt_chunk_at_byte_slice(ref gen_text in "\\PC*\\n?\\PC*\\n?\\PC*", range in (0usize..1000000, 0usize..1000000)) {
372 let r = Rope::from_str(&gen_text);
373 let mut idx1 = range.0 % (r.len_chars() + 1);
374 let mut idx2 = range.1 % (r.len_chars() + 1);
375 if idx1 > idx2 {
376 std::mem::swap(&mut idx1, &mut idx2)
377 };
378 let s = r.slice(idx1..idx2);
379 let text = string_slice(&gen_text, idx1, idx2);
380
381 let mut t = text;
382 let mut prev_chunk = "";
383 for i in 0..s.len_bytes() {
384 let (chunk, b, c, l) = s.chunk_at_byte(i);
385 assert_eq!(c, byte_to_char_idx(text, b));
386 assert_eq!(l, byte_to_line_idx(text, b));
387 if chunk != prev_chunk {
388 assert_eq!(chunk, &t[..chunk.len()]);
389 t = &t[chunk.len()..];
390 prev_chunk = chunk;
391 }
392
393 let c1 = {
394 let i2 = byte_to_char_idx(text, i);
395 text.chars().nth(i2).unwrap()
396 };
397 let c2 = {
398 let i2 = i - b;
399 let i3 = byte_to_char_idx(chunk, i2);
400 chunk.chars().nth(i3).unwrap()
401 };
402 assert_eq!(c1, c2);
403 }
404
405 assert_eq!(t.len(), 0);
406 }
407
408 #[test]
409 fn pt_chunk_at_char_slice(ref gen_text in "\\PC*\\n?\\PC*\\n?\\PC*", range in (0usize..1000000, 0usize..1000000)) {
410 let r = Rope::from_str(&gen_text);
411 let mut idx1 = range.0 % (r.len_chars() + 1);
412 let mut idx2 = range.1 % (r.len_chars() + 1);
413 if idx1 > idx2 {
414 std::mem::swap(&mut idx1, &mut idx2)
415 };
416 let s = r.slice(idx1..idx2);
417 let text = string_slice(&gen_text, idx1, idx2);
418
419 let mut t = text;
420 let mut prev_chunk = "";
421 for i in 0..s.len_chars() {
422 let (chunk, b, c, l) = s.chunk_at_char(i);
423 assert_eq!(b, char_to_byte_idx(text, c));
424 assert_eq!(l, char_to_line_idx(text, c));
425 if chunk != prev_chunk {
426 assert_eq!(chunk, &t[..chunk.len()]);
427 t = &t[chunk.len()..];
428 prev_chunk = chunk;
429 }
430
431 let c1 = text.chars().nth(i).unwrap();
432 let c2 = {
433 let i2 = i - c;
434 chunk.chars().nth(i2).unwrap()
435 };
436 assert_eq!(c1, c2);
437 }
438 assert_eq!(t.len(), 0);
439 }
440
441 #[test]
442 fn pt_chunk_at_line_break_slice(ref gen_text in "\\PC*\\n?\\PC*\\n?\\PC*", range in (0usize..1000000, 0usize..1000000)) {
443 let r = Rope::from_str(&gen_text);
444 let mut idx1 = range.0 % (r.len_chars() + 1);
445 let mut idx2 = range.1 % (r.len_chars() + 1);
446 if idx1 > idx2 {
447 std::mem::swap(&mut idx1, &mut idx2)
448 };
449 let s = r.slice(idx1..idx2);
450 let text = string_slice(&gen_text, idx1, idx2);
451
452 // First chunk
453 {
454 let (chunk, b, c, l) = s.chunk_at_line_break(0);
455 assert_eq!(chunk, &text[..chunk.len()]);
456 assert_eq!(b, 0);
457 assert_eq!(c, 0);
458 assert_eq!(l, 0);
459 }
460
461 // Middle chunks
462 for i in 1..s.len_lines() {
463 let (chunk, b, c, l) = s.chunk_at_line_break(i);
464 assert_eq!(chunk, &text[b..(b + chunk.len())]);
465 assert_eq!(c, byte_to_char_idx(text, b));
466 assert_eq!(l, byte_to_line_idx(text, b));
467 assert!(l < i);
468 assert!(i <= byte_to_line_idx(text, b + chunk.len()));
469 }
470
471 // Last chunk
472 {
473 let (chunk, b, c, l) = s.chunk_at_line_break(s.len_lines());
474 assert_eq!(chunk, &text[(text.len() - chunk.len())..]);
475 assert_eq!(chunk, &text[b..]);
476 assert_eq!(c, byte_to_char_idx(text, b));
477 assert_eq!(l, byte_to_line_idx(text, b));
478 }
479 }
480
481 #[test]
482 fn pt_slice(ref text in "\\PC*", range in (0usize..1000000, 0usize..1000000)) {
483 let rope = Rope::from_str(&text);
484
485 let mut idx1 = range.0 % (rope.len_chars() + 1);
486 let mut idx2 = range.1 % (rope.len_chars() + 1);
487 if idx1 > idx2 {
488 std::mem::swap(&mut idx1, &mut idx2)
489 };
490
491 let slice = rope.slice(idx1..idx2);
492 let text_slice = string_slice(&text, idx1, idx2);
493
494 assert_eq!(slice, text_slice);
495 assert_eq!(slice.len_bytes(), text_slice.len());
496 assert_eq!(slice.len_chars(), text_slice.chars().count());
497 }
498
499 #[test]
500 fn pt_byte_to_line_idx(ref text in "[\\u{000A}\\u{000B}\\u{000C}\\u{000D}\\u{0085}\\u{2028}\\u{2029}]*[\\u{000A}\\u{000B}\\u{000C}\\u{000D}\\u{0085}\\u{2028}\\u{2029}]*", idx in 0usize..200) {
501 let idx = idx % (text.len() + 1);
502 assert_eq!(
503 byte_to_line_index_slow(text, idx),
504 byte_to_line_idx(text, idx),
505 );
506 }
507
508 #[test]
509 fn pt_line_to_byte_idx(ref text in "[\\u{000A}\\u{000B}\\u{000C}\\u{000D}\\u{0085}\\u{2028}\\u{2029}]*[\\u{000A}\\u{000B}\\u{000C}\\u{000D}\\u{0085}\\u{2028}\\u{2029}]*", idx in 0usize..200) {
510 let line_count = byte_to_line_idx(text, text.len());
511 let idx = idx % (line_count + 1);
512 assert_eq!(
513 line_to_byte_index_slow(text, idx),
514 line_to_byte_idx(text, idx),
515 );
516 }
517
518 #[test]
519 fn pt_byte_to_char_idx(ref text in "\\PC*\\PC*\\PC*", idx in 0usize..200) {
520 let idx = idx % (text.len() + 1);
521 let mut idx_2 = idx;
522 while !text.is_char_boundary(idx_2) {
523 idx_2 -= 1;
524 }
525 assert_eq!(
526 (&text[..idx_2]).chars().count(),
527 byte_to_char_idx(text, idx),
528 );
529 }
530
531 #[test]
532 fn pt_char_to_byte_idx(ref text in "\\PC*\\PC*\\PC*", idx in 0usize..200) {
533 let len_chars = byte_to_char_idx(text, text.len());
534 let idx = idx % (len_chars + 1);
535 if idx < len_chars {
536 assert_eq!(
537 text.char_indices().nth(idx).unwrap().0,
538 char_to_byte_idx(text, idx),
539 );
540 } else {
541 assert_eq!(
542 text.len(),
543 char_to_byte_idx(text, idx),
544 );
545 }
546 }
547
548 #[test]
549 fn pt_cmp(ref text1 in "\\PC*", ref text2 in "\\PC*") {
550 let r1 = Rope::from_str(text1);
551 let r2 = Rope::from_str(text2);
552
553 assert_eq!(r1.cmp(&r2), text1.cmp(text2));
554 assert_eq!(r2.cmp(&r1), text2.cmp(text1));
555 }
556
557 #[test]
558 fn pt_bytes_iter_next(ref text in
559 "\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
560 \\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
561 \\PC*\\PC*\\PC*\\PC*\\PC*",
562 idx1 in 0usize..20000, idx2 in 0usize..20000,
563 ) {
564 let len_chars = byte_to_char_idx(text, text.len());
565 let idx1 = if len_chars == 0 { 0 } else { idx1 % len_chars };
566 let idx2 = if len_chars == 0 { 0 } else { idx2 % len_chars };
567 let start = idx1.min(idx2);
568 let end = idx1.max(idx2);
569
570
571 let r = Rope::from_str(text);
572 let text = string_slice(text, start, end);
573 let s = r.slice(start..end);
574
575 let mut idx = 0;
576 for byte in s.bytes() {
577 assert_eq!(byte, text.as_bytes()[idx]);
578 idx += 1;
579 }
580 }
581
582 #[test]
583 fn pt_bytes_iter_prev(
584 ref directions in vec(0u8..2, 0..1000),
585 idx1 in 0usize..CHAR_LEN,
586 idx2 in 0usize..CHAR_LEN,
587 ) {
588 let start = idx1.min(idx2);
589 let end = idx1.max(idx2);
590
591 let r = Rope::from_str(TEXT);
592 let s = r.slice(start..end);
593
594 let mut itr = s.bytes();
595 let mut bytes = Vec::new();
596 for i in directions {
597 if *i == 0 {
598 assert_eq!(itr.prev(), bytes.pop());
599 } else if let Some(byte) = itr.next() {
600 bytes.push(byte);
601 }
602 }
603 }
604
605 #[test]
606 fn pt_chars_iter_next(ref text in
607 "\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
608 \\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
609 \\PC*\\PC*\\PC*\\PC*\\PC*",
610 idx1 in 0usize..20000, idx2 in 0usize..20000,
611 ) {
612 let len_chars = byte_to_char_idx(text, text.len());
613 let idx1 = if len_chars == 0 { 0 } else { idx1 % len_chars };
614 let idx2 = if len_chars == 0 { 0 } else { idx2 % len_chars };
615 let start = idx1.min(idx2);
616 let end = idx1.max(idx2);
617
618
619 let r = Rope::from_str(text);
620 let text = string_slice(text, start, end);
621 let s = r.slice(start..end);
622
623 for (c1, c2) in s.chars().zip(text.chars()) {
624 assert_eq!(c1, c2);
625 }
626 }
627
628 #[test]
629 fn pt_chars_iter_prev(
630 ref directions in vec(0u8..2, 0..1000),
631 idx1 in 0usize..CHAR_LEN,
632 idx2 in 0usize..CHAR_LEN,
633 ) {
634 let start = idx1.min(idx2);
635 let end = idx1.max(idx2);
636
637 let r = Rope::from_str(TEXT);
638 let s = r.slice(start..end);
639
640 let mut itr = s.chars();
641 let mut chars = Vec::new();
642 for i in directions {
643 if *i == 0 {
644 assert_eq!(itr.prev(), chars.pop());
645 } else if let Some(c) = itr.next() {
646 chars.push(c);
647 }
648 }
649 }
650
651 #[test]
652 fn pt_chunks_iter_next_01(ref text in
653 "\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
654 \\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
655 \\PC*\\PC*\\PC*\\PC*\\PC*",
656 idx1 in 0usize..20000, idx2 in 0usize..20000,
657 ) {
658 let len_chars = byte_to_char_idx(text, text.len());
659 let idx1 = if len_chars == 0 { 0 } else { idx1 % len_chars };
660 let idx2 = if len_chars == 0 { 0 } else { idx2 % len_chars };
661 let start = idx1.min(idx2);
662 let end = idx1.max(idx2);
663
664
665 let r = Rope::from_str(text);
666 let text = string_slice(text, start, end);
667 let s = r.slice(start..end);
668
669 let mut idx = 0;
670 for chunk in s.chunks() {
671 assert_eq!(chunk, &text[idx..(idx + chunk.len())]);
672 idx += chunk.len();
673 }
674 }
675
676 #[test]
677 fn pt_chunks_iter_next_02(idx1 in 0usize..CHAR_LEN, idx2 in 0usize..CHAR_LEN) {
678 let start = idx1.min(idx2);
679 let end = idx1.max(idx2);
680
681 let r = Rope::from_str(TEXT);
682 let text = string_slice(TEXT, start, end);
683 let s = r.slice(start..end);
684
685 let mut idx = 0;
686 for chunk in s.chunks() {
687 assert_eq!(chunk, &text[idx..(idx + chunk.len())]);
688 idx += chunk.len();
689 }
690 }
691
692 #[test]
693 fn pt_chunks_iter_prev_01(ref text in
694 "\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
695 \\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\\PC*\
696 \\PC*\\PC*\\PC*\\PC*\\PC*",
697 ref directions in vec(0u8..2, 0..1000),
698 idx1 in 0usize..20000, idx2 in 0usize..20000,
699 ) {
700
701 let r = Rope::from_str(text);
702
703 let idx1 = if r.len_chars() == 0 { 0 } else { idx1 % r.len_chars() };
704 let idx2 = if r.len_chars() == 0 { 0 } else { idx2 % r.len_chars() };
705 let start = idx1.min(idx2);
706 let end = idx1.max(idx2);
707
708 let s = r.slice(start..end);
709
710 let mut itr = s.chunks();
711 let mut chunks = Vec::new();
712 for i in directions {
713 if *i == 0 {
714 assert_eq!(itr.prev(), chunks.pop());
715 } else if let Some(chunk) = itr.next() {
716 chunks.push(chunk);
717 }
718 }
719 }
720
721 #[test]
722 fn pt_chunks_iter_prev_02(
723 ref directions in vec(0u8..2, 0..1000),
724 idx1 in 0usize..CHAR_LEN,
725 idx2 in 0usize..CHAR_LEN,
726 ) {
727 let start = idx1.min(idx2);
728 let end = idx1.max(idx2);
729
730 let r = Rope::from_str(TEXT);
731 let s = r.slice(start..end);
732
733 let mut itr = s.chunks();
734 let mut chunks = Vec::new();
735 for i in directions {
736 if *i == 0 {
737 assert_eq!(itr.prev(), chunks.pop());
738 } else if let Some(chunk) = itr.next() {
739 chunks.push(chunk);
740 }
741 }
742 }
743
744 #[test]
745 fn pt_bytes_at_01(idx in 0usize..TEXT.len()) {
746 let r = Rope::from_str(TEXT);
747 let mut bytes_r = r.bytes_at(idx);
748 let text_bytes = TEXT.as_bytes();
749
750 for i in idx..r.len_bytes() {
751 assert_eq!(bytes_r.next(), Some(text_bytes[i]));
752 }
753 }
754
755 #[test]
756 fn pt_bytes_at_02(idx in 0usize..TEXT.len()) {
757 let r = Rope::from_str(TEXT);
758 let mut bytes_r = r.bytes_at(idx + 1);
759 let text_bytes = TEXT.as_bytes();
760
761 let mut i = idx + 1;
762 while i > 0 {
763 i -= 1;
764 assert_eq!(bytes_r.prev(), Some(text_bytes[i]));
765 }
766 }
767
768 #[test]
769 fn pt_chars_at_01(idx in 0usize..CHAR_LEN) {
770 let r = Rope::from_str(TEXT);
771 let mut chars_r = r.chars_at(idx);
772 let chars_t = (&TEXT[char_to_byte_idx(TEXT, idx)..]).chars();
773
774 for c in chars_t {
775 assert_eq!(chars_r.next(), Some(c));
776 }
777 }
778
779 #[test]
780 fn pt_chars_at_02(idx in 0usize..CHAR_LEN) {
781 let r = Rope::from_str(TEXT);
782 let mut chars_r = r.chars_at(idx);
783 let mut chars_t = (&TEXT[..char_to_byte_idx(TEXT, idx)]).chars();
784
785 while let Some(c) = chars_t.next_back() {
786 assert_eq!(chars_r.prev(), Some(c));
787 }
788 }
789
790 #[test]
791 fn pt_bytes_iter_exact_01(idx in 1024usize..(CHAR_LEN - 1024)) {
792 let r = Rope::from_str(TEXT);
793 let s = r.slice(idx..(idx + 373));
794
795 // Forward
796 {
797 let mut byte_count = s.len_bytes();
798 let mut bytes = s.bytes();
799
800 assert_eq!(byte_count, bytes.len());
801
802 while let Some(_) = bytes.next() {
803 byte_count -= 1;
804 assert_eq!(byte_count, bytes.len());
805 }
806
807 assert_eq!(byte_count, 0);
808 assert_eq!(bytes.len(), 0);
809 }
810
811 // Backward
812 {
813 let mut byte_count = 0;
814 let mut bytes = s.bytes_at(s.len_bytes());
815
816 assert_eq!(byte_count, bytes.len());
817
818 while bytes.prev().is_some() {
819 byte_count += 1;
820 assert_eq!(byte_count, bytes.len());
821 }
822
823 assert_eq!(byte_count, s.len_bytes());
824 assert_eq!(bytes.len(), s.len_bytes());
825 bytes.prev();
826 assert_eq!(bytes.len(), s.len_bytes());
827 }
828 }
829
830 #[test]
831 fn pt_chars_iter_exact_01(idx in 1024usize..(CHAR_LEN - 1024)) {
832 let r = Rope::from_str(TEXT);
833 let s = r.slice(idx..(idx + 373));
834
835 // Forward
836 let mut char_count = s.len_chars();
837 let mut chars = s.chars();
838
839 assert_eq!(char_count, chars.len());
840
841 while let Some(_) = chars.next() {
842 char_count -= 1;
843 assert_eq!(char_count, chars.len());
844 }
845
846 assert_eq!(char_count, 0);
847 assert_eq!(chars.len(), 0);
848
849 // Backward
850 let mut char_count = 0;
851 let mut chars = s.chars_at(s.len_chars());
852
853 assert_eq!(char_count, chars.len());
854
855 while chars.prev().is_some() {
856 char_count += 1;
857 assert_eq!(char_count, chars.len());
858 }
859
860 assert_eq!(char_count, s.len_chars());
861 assert_eq!(chars.len(), s.len_chars());
862 chars.prev();
863 assert_eq!(chars.len(), s.len_chars());
864 }
865
866 #[test]
867 fn pt_lines_iter_exact_01(idx in 1024usize..(CHAR_LEN - 1024)) {
868 let r = Rope::from_str(TEXT);
869 let s = r.slice(idx..(idx + 373));
870
871 // Forward
872 let mut line_count = s.len_lines();
873 let mut lines = s.lines();
874
875 assert_eq!(line_count, lines.len());
876
877 while let Some(_) = lines.next() {
878 line_count -= 1;
879 assert_eq!(line_count, lines.len());
880 }
881
882 assert_eq!(line_count, 0);
883 assert_eq!(lines.len(), 0);
884
885 // Backward
886 let mut line_count = 0;
887 let mut lines = s.lines_at(s.len_lines());
888
889 assert_eq!(line_count, lines.len());
890
891 while lines.prev().is_some() {
892 line_count += 1;
893 assert_eq!(line_count, lines.len());
894 }
895
896 assert_eq!(line_count, s.len_lines());
897 assert_eq!(lines.len(), s.len_lines());
898 lines.prev();
899 assert_eq!(lines.len(), s.len_lines());
900 }
901 }
902
903 //===========================================================================
904
905 // Char count of TEXT, below
906 const CHAR_LEN: usize = 18267;
907
908 // 31539 bytes, 18267 chars, 95 lines
909 // Contains many long graphemes.
910 const TEXT: &str = "
911 T̴̷͚͖̜͈̪͎͔̝̫̦̹͔̻̮͂ͬͬ̌ͣ̿ͤ͌ͥ͑̀̂ͬ̚͘͜͞ô̵͚̤̯̹͖͍̦̼̦̖̞̺͕̳̬͇͕̟̜̅̌̈́̑̏̕͘͝ ͍̼̗̫͈̭̦̱̬͚̱̞͓̜̭̼͇̰̞ͮ͗ͣ́ͪ̔ͪ̍̑̏́̀̽̍̔͘͜͜͝ȋ̐̽ͦ̓̔̅͏̧̢̖̭̝̳̹̯̤͈̫͔͔̠͓͉̠͖̠͜ͅn̷̯̗̗̠̱̥͕͉̥͉̳̫̙̅͗̌̒͂̏͑̎̌̌̊͌͘͘ͅͅv̧̜͕͍͙͍̬͕͍̳͉̠͍̹̮̻̜ͨ̏͒̍ͬ̈́͒̈ͥ͗ͣ̄̃ͤ͊̌͆̓o̸̧̎̓͂̊͢҉͍̼̘͇̱̪̠͎̥̹ķ̈́͗͆ͥ͐͑̆̎́͌ͩͯ̊̓͐ͬ̇̕҉̢͏͚̲̰̗̦e̿̀͐̽ͪ̈ͤͬ҉́͟͏̵̫̲̱̻̰̲̦͇̭̟̺͈̞̫̰̜͕͖ͅ ̡̰͎͓͚͓͉͈̮̻̣̮̟̩̬̮̈̋̊͆ͪ̄ͪ͒ͨͧ̇ͪ̇̑̚t̷̬̟͎̞͈̯͙̹̜ͩ̓ͪ͛͐̐ͤ̾̄̈͒̽̈́̑͒̏h̨̢̳͇͓͉̝ͫ̐̓̆̓ͮ̔̓̈́̇ͫe̟̬̣̗͚̬̾̉͋̽ͯ̌ͯͬ̂ͯͭ̓͛́̚͡ ̨̭̱͉̭͈̈̽̆̂͒͗̀ͥͩ͡h̻̼̱̹̗͖̙̗̲̤͓͇͚͚̻̞̥ͥ͛͌ͧ̚͟i̢̯̹̹̘̳̙ͩ̉ͥ͆̽̇̾̎͗̔̓͂͂́̓̌ͬv̧̡̛̟̜̠͉͖̘̲̻̯͚͍͓̯̻̲̹̥͇̻̿̓͛̊̌ͩͩ́ͩ̍͌̚e̵̾́̈́̏͌͌̊͗̏͋ͦ͘͡͏͚̜͚͎͉͍̱͙̖̹̣̘̥̤̹̟͠-̔̌͐́͒ͦͮ̇ͭ̄̏̊̇̍̕͏̩̥̰͚̟m̨̒ͫͦ̔̔͋҉̱̩̗͇̥̰̩̭͍͚͠į̵̷̻̗͉͕͚̣̼̺͉̦̮̠̆̀̐ͩ͒ͯͩͯ͞ͅn̢̫̤̝̝͚̺͍̱̦͚͂̿ͨ̇ͤ͠d̡ͯ͋̋ͧ̈́̒̈͏̛͏̵̤̬͍̗̞̠̟̞̺̠̥̹̱͉̜͍͎̤ ̷̸̢̰͓̘̯͎̤̫̘͓̙̟̳͇̹̥͈͙̮̩̅̋͌͗̓͊̓ͨͣ͗̓͐̈́ͩ̓ͣrͫ͂͌ͪ̏̐̍̾ͥ̓͗̈͆̈ͥ̀̾̚̚҉̴̶̭͇̗͙̘̯̦̭̮̪͚̥̙̯̠͙̪͡e̵̸̲͉̳̙͖͖̫̘̪͕̳͓̻̙͙ͥ̍͂̽ͨ̓̒̒̏ͬ͗ͧ̑̀͠p̵̸̛̦̣͙̳̳̩̣̼̘͈͂ͪͭͤ̎r̶̩̟̞̙͔̼ͫ̆ͦ̐̀̏̾̉̍ͬ̅ͧ͊ͪ̒̈́ͬ̃͞ẻ̴̼͙͍͎̠̀̅̔̃̒͐ͦ̏̆̅̓͋͢ͅš̆̈̆̋ͨ̅̍̇͂̒ͩͨ̂̐̓ͩ͏̸͔͔̯͇͚̤̪̬̗͈̰̦̯͚̕ę̢̱̠͙̲͉̗͚̮̪͖̙̞̦͉͕̗̳͙ͦ̆̋͌ͣ̅̊́ͅņ̴̷̫̪̦͇̺̹͉̗̬̞̲̭̜̪͒̏͂̂̎͊́̋͒̏̅̋̚͘t̷̶̨̟̦̗̦̱͌͌ͩ̀i̴̴̢̖͓͙̘͇̠̦̙̭̼͖̹̾̒̎̐ͥͭ͋ͥ̅͟ͅņ̫͙̹̦̳͈͙̬̫̮͕̰̩̣̘̘͐̀̓ͭͩͬͯ̎͛̿ͫ̊̔̅́̕͠gͥͩ̂͌̒̊̕͏̻͙͖̣͙͍̹͕̝͖̼̙̘͝ ͤ͐̓̒̓͋̐̃̇͊̓ͦ͐̚͢҉̢̨̟̠͉̳͖̲̩͙̕ć̷̡̫̩̞̯̼̝̼͖̤̳̻̘̪̤͈̦̭ͣ́͂͐̽͆̔̀̚͜h̶̢̹̹̙͔̱̓ͦ͌̋̎ͭ͒͋̒ͭ̌̃͌̿ͣ̆̅͑ą̙̳̬̞̬͚̜̤̱̙͇̠̟̈ͤ͋̃̀̓̓ͯ̍̀̽ͣ̐̈̿̌̕ǫ͋͂͐ͬ̿ͯ̂̈́͌̓̌ͧ̕͏̜͔̗͚͔̘̣͕̘̲͖̼͇͖̗̳ͅͅs̷̸̝̙̭̦̣̦̯̭̦͙̹̻͍͇̣̼͗̌͆ͨͭ̃ͮ͐̿̕.̮̝̠̱̺͖͓̼̦̱̉͂͛̓̑̔̓ͮ̈̊̔͗́͝\r
912 ̛̣̺̻̼̙̼͓̱̬͕̩͕̲̳̭̗̍ͤ͋̒̆̄ͨ̿ͧ̓͠ͅI̷̻̤̳̲͔͈̖̬̰͔̪͇͇̟̋ͨ̋̍̉̔͝͞͝ͅn̶͕̭͖̠̣͚̹̪͆ͪ̇̂̅̾ͫ́̅̉ͭ̀͜v̖͉̩͕̣͔̭͕̩̲̖̇̀ͬ́̄͒̆͑͆ͪͤ͆̾̍ͯ̚͜ǫ̡̡̫͎̟̞̰̞̹͇̲̏ͨ̄͊̊̇͒̽͢ķ̶̪̙̰̥͙̞̹̭̺͍͕̙̲̮͊ͭ́͋͛͋̑̒͊̏̒̅͛̄̓͟i̴͎̹̞̥͖̒̄ͮ̒̾ͮͧ̀̚͡n̸̵͓̲̟̞̳͚̼̣͙͖̈ͦ͒̿̅̒̿͛͊̇ͧ̉g̡̧̪̩͚͙͓̪͓͚͉̥̪͍̙̻͖͇͗̑͊͑̾̍͊̀ͅ ̷̵̠͚̘̟͓̫̣̲͎̩̹̣̼̟͊́̏ͫ̆ͩ̓͋͆̿̽̓͘̕t̴̢̝̻̖̲̬̜̺̖̻ͩ̿ͫ͗̈́̔͑̐ͮͦ̽̉̓̚͜h̷̛̲͇̫͈̣̭͂ͭ̂͋ͭ̋̔ͮ̆ͩ͞ë̩͕͉̯͇͔͚̭̼̮̣͓̯́ͭ̀ͣ͗̋̉ͨͬ̒ͥͩ͆̓̓́̀̚͘͝ ̛̫̠̗̥̳͇͉̟̮̪̻̤̪͚̟̜̔̌͌̈͌ͪ̋̎̄ͯ͐ͦ́͞͠fͦ̂̈ͬ̇̅̓̓ͫͣ̉̂̉̚͘͡͡͏̼̖̟͚̙̳͔͎̲̫̦̯͔̣̼̹ě̷̶̫͎̞̺̪̪͇͈̞̳̏̋̋͋̾̓̽̓̑ͮ͊ͣ̋̃̅̀͡e͇̗͎̱͔̦̠̰̩̩͖͙̠̻̝ͯ̿̔̀͋͑ͧ͊̆̇̿ͤ̄ͯ̇̀͢͠ͅl̂̿ͯ͛̊̒̓̈́͏̵̪̦̞̤̫̤͇̙̗͕͎̪͕̙̻̳̗̕͟͢i̞̣̙͎͈̗̮͉̱̜̱̝̞̤͋ͯ͋͐̈́ͫ̉̊̏̀ͯͨ͢͟͝n̳̻̼̥̖͍̭̅͂̓̔̔ͦ̔́ͦ͊̀͛̈́ͬͦ͢͡͡ģ̶̡̳̰̻̙̞̱̳̣̤̫̫͕̤̮̰̬̪̜͋͒̎̈́̉̏̀ͬͯ͌̇͊̚ ́̽ͤͦ̾̔͢҉̛̤͍͉̺̙̮̗̜̟̀͝ơ̢̱͓͓̙͉̖̠̯̦̗͍̓̐̃̉̅̃ͨ͆́ͪ̂̒̀̊̃͆̔͡͡ͅf́ͬ̊ͯͫ̉̈́̽̉̚͢͏̡̺̬̖͇̫͉̱ ̴͇̦̗̙̼̬͓̯͖̮͓͎̗͈̻̈́͆ͭ̐ͦ́͛̀͋̐̌ͬ͑̒̊̿̃͞c̶̸̣͔̬͕̪̱̩̣̑̒̑̓̍̓͂̍̔͌̚͘͜͞h̶͈̱͇͉̳͍͍̰͈͖̬̥͚̯͓̞̹̋̔ͯ̑̃́̒̎̎͊̈́̍̚̕ạ̴̞̱̥͍͙̺͉͚͎̫̦͎̥ͩ̀̀̊ͥ͢o̵̧͕̜͓͈̬̰̫̮͙̹͉̩̝̩͎̓̆͗̿̊̀ͯ̃ͪ̊ͫ̽̉̓ͧ͗́̚͢ͅͅs̡ͫ͋̑ͮ̍̃͊̄ͬ̅̈́ͬ̍̇̔̈̅̍̀҉̜͓̝̘̘̮̼͖͎̻͓͖̖͙̞ͅ.͗ͬͭͩ̌̅͗͏̷̮̗͇͔͇͈̮͢\r
913 ̨͚̲̫̠̼͖̝̻̉ͤ̅̂ͩ̀̇ͬͭ̀͜Ẅ̢́̉͌ͮͬͨ͊̏͌̇̐͊͟͠҉̼̰̦̩͇͕̟̭̪̲͕̥͖̰̪͈̀ͅͅį̷ͣͦ̉̍ͨ͂͂͑̃͂ͪ̊̈̋̄͜҉̨͚̟̲̯̹̺̝̭̺̙͖͍t̼͓̰̩͙̦͓̟͚͖̀ͯ͛̍̈́͑͂̍̋́h̛̼̺̘̥̠̼̼̭͙̮͚̱̍ͯ̓̃̐̂̇͟ ̴̛͖͔̰̠̺̥̲ͮ̍ͫ̽͜õ̒ͯ̒̓ͦ̈́͑̔̒̓̎ͤ͑҉̸̭̱̤̭̬͈ų̙̫̤͖̺̫̱͓͓̗̪͇̩̙̔̉̊͂ͪ̇͢͟͞ͅt̸̬̣̫̞̫̅͐ͮ̌͌̈́̀̀͘ ̷̴̨̖̙̹͚ͬ̈́̈ͯͨͮ̇̈́̋̈́ͭ͛̑̉͊̕ö̡̍ͥ̂ͬͪͧ͒ͧ̏̓̇̂̄͆̌ͫͤ͢͠͝͏̖̱̯̘͙̰̖͎̰͓̟̤ṙ̡̬̟̬̜̪̮̺͖̗̘͈̟ͨ͐͗̑͒̐d̢ͭͫ̊̏ͬͥ͋́̌̈́ͮ̆ͬ̐̌̎͏̵̷̡̞̲̹̙͕̮̮͚ḙ̴̸̠͔͎̥͇͖͕̘̍̓̏̐ͩͩ̈́ͦ̐̋ͤ̎̾̌̏͊̊́̚͞ͅr̸͈̗̣̲̗̣̬̤ͦ̎ͫ̏̀ͥͪ̋ͧ̄͑̋͒͌͋ͦ̉͟͞.ͨͣ̽̈́͒̄ͮ̀͋͋͏̴̧̯̺̙̱̻͙̜\r
914 ̡̣̞̠͓̰͍̠͕̭̺̼͊̽̿͊ͮ̐̓̒̊͒̔̓͐ͨ̈̌́T̸̸̓́̋ͬ́͆ͨͫ͌͂ͣ̋͒҉̺̝͎̟͖͚̠h̸̡̰̜̦͇͕̪̝̳͕͉̲̝̑ͥ͋ͧ̎̆͌͟e̛̹͍͍̫̙̞̪̭̙̟͙̱̺̮̳͕̜ͫ̓ͭ͊ͫ͆̀̚͟͡ ̿͂̄ͧ̔̎ͧ͑̾̀̓͏̦͍̳͈̳͔̘̖̲̯̰̟̝̳̖̦N̶̡̧̦̮̟̦̩̰̣̝̆̀͊̔͢e͛̄ͮͦͨ͂̔̓̍̄̉͆͊̑̑̆̚͏̜̗͎̝̼̯̥̜͖͍̪̝͞ͅͅz̨̛̀̾ͪ͗̉́͠͏͚̫̼̫̜̣pͪͦ͌̄ͥ̆ͣͩ͋̉́̏͞͏̥̜̝̳̱̞̙̳̤͙̟̟̮̦ȅ̷̩̟͉̯͕͔̘̺̥̻̻ͧ̊̅̽ͣ͑̓̑̽ͦ̾͌͜r̴̭̥̲̲̤͚͈̰͇̰͈̰̹ͫ̒ͯ̿͒ͧ̊͆͒ͣ́ḍ̭̟̤̈́̌̓̈́ͫ͐̍͂͞į̛̞̝̮̣͙͙̤̇̂̓̎͋̿̓̎̄̈́ͧ̓ͩ̐̓̄̋ͭ͞͠a͋̔̋ͫ̂͐͂҉̸̛̥̩̯̯̤̝͔̠̝̯̪̥̩̻̼̮n͌ͣ̂͋̿̚҉̛̙̲̺̯͇͓̝̯̪̟͔̩͟ͅ ̢̨͚̻̗̘͖̯̐ͥ͋̽ͯ̎̈́͋̏̄͋̆̑̊̆̚̕͟ͅh̢̛̗̱̭͇͖̰̮̮͈̲͍̯̟ͭ͊̎̽̓ͦͤ͠ï̛̘̝̦͎̦̭̠͖̳͎̮̼̏͐ͧ̒̒͐͑ͪͫ̋̽̚̚͜v̴̮͕̝̮̞͐̄͗̋͒ͤ̎̈̑ͬͮ̄̾ͤ̓̾͊͗͟é̶̷̡̩͖̰̫͓̟ͮͬͣ͊-ͦ͛ͩͤͨͨ̆̄͏̼̜̭͔̳͈͖̳̩͢ͅͅm̷̴̓́̓͛͒̾̍̉҉̛̗̹̠̣̪̺͎̖̝͚̖͙i̛̥͓̬̫͉͕͉͆͒ͧ̂̿̔̔͆̆̓̍͊̀͜n͌ͧͣ̅̌̎ͦͦ͑̑ͭ̆ͬ̀ͤ̀ͣ̚҉͎̰̱͚͈͈̬̹͕̺̙͙̼͘͘͞d̶͖̫̟̲͕̺̠͎̘͕̱̼͙̪̪̩͙̅̅̑̓̇͑̊̉͜͞ ̶̵̷̴̡̠͚̪͕̣̱̖̱̗̤̭̭͔͖͚ͧͤͥ͒̌ͪ͊͂͒̓͂ͧͧ̇̇͐̑̔ͅͅơ̵̲̲͇̯̰͇̜̣͕͕͓̲̤̲͔͚̞͑͗ͤ̓́̚͠ͅf̢̧̛̩̯̼̫͖̾ͣ͌̾̉́̈́̑̈́̚͞͞ͅ ͤͩ́͋͒ͫͬͣ̋̅̆҉̧̱̻͓͕͉̹̫̫̞̯̪̙̩͍̦͔̖̮̀͟ͅc͉̠̜̩̟͕͎̙̣̮̘̼͋ͯ̍ͨ̅̄ͫ̈̋ͫ̊͡͝ȟ̸̨ͯͦ̂̉̇̾̆ͭ̋̐̈̆̀̚͜҉͚͕̻̖a̶̴̛͚̗͙̳̬̲͚ͦ́̐ͥ́̔̅̑̎͐̑ͯ̾ͤͥͧ͡ò̶̧̞̪̦̥̪̻̦̝̳̬̔͛͛ͣ̋̌̔ͫ̂̽ͫ͘͠s̸̖̣̬̤̫͇̫̣̑͆͒̎̏́͟.̴̗̤̭͉̯̻̤͕̌ͯ̍ͤ̓͌ͤ̈̆̉ͦ̇́̚͘͟͝ͅ ̯̹̪͓̬͌̔̌ͬ̀͘͢͡͡Z̡̩̲̩̰̫̩̟͍̰͖͔̭ͣ̆̾ͭ̀́͞ͅa̡̡̙̜̭͇͎͔̙̞̫͓̜͉͔̬ͭ̈ͨ̉͆ͣͫ̃͌̓͌́ͣͥ̒̌͊͘͝l̢̨̡̯̙̫͖̫̺̘̬̟͈͌̊ͧͫͦ̉̃ͩͦ̒ͯ̇̌̓͛͟͝ͅg̵̙̼̼ͪ͂ͭ͗̈̕ȯ̅ͧ̓ͪ́̂͑̐ͩͥͬ̊̑͆̇͒ͫͣ͝҉͎̟̜̥͎̮̣͉̖̟̯̦̖͙͙͞ͅ.̈̑ͩ̇̂ͬ̓ͬ͊͂ͨ̽͠͏̺͎̞̦̜͍͚̯̯͔̝̞̻̩̖\r
915 ̷̰̪͍͎͔͒ͯͥ̾̉͆ͤ̊̓̂͋̀͆H̸̸̹̞̙̺͎̠̯̤ͨ̉̍ͬͤ̓̐͌ͥͮ͞eͣ̈̾͛́͏͕̗͍̜̼͎͚̟̬̣̝̕ͅͅ ̴̛̩̗̼̝̣̩͚͇̯́̉͋̂̍͂̌ͮ͋̾͜͠wͮ̽̓ͭ̿͐̽̐̽͆̓͝҉̡̼̲͖̪̥h̢̢̛͍̰̰̻̱̼̰̹̖̖̪̝̥̘̎̀ͪ͒̾ͫͬ̆̑o̡̗̠̞̱̥͎̰͎͍̫̻͓͇͓͐ͥͯ͂̅͠ͅ ̡̛̏͑ͦ̓͊ͮͫͯͭ̌͒̆̍̈͠҉͖͚̪̫̗̮W̴̐̊͋̾ͥͫ҉͎̞͔̯̫̹͖̰͉̹̼͎̰̱͓̻̀a̶̩̤̙̣͎̳̭̲̗̠͉̳̭̭̦̞͎̮̅͌̾͗̾͛̇̀́͟͞ͅi̷̡ͣ̆̌͋͒͒́͘͏̮̺̩͎͇̜͍̫ṯ̴̢͖̥̖͇͎̦̦̹̖͇̪ͭ̅̍͐̇͒͋̽̏̿̒͆ͧ̄͋ͧͩ͒͜s̙̥̖̘̖͚̭̤̮̖̘̰̫̟̈́ͣ̍ͧ͐ͥ̏͆̃̿͒̔͐́̚͟ͅ ̨ͭ̌ͬͯ͆̒͋ͭ̔̿ͧ̅̓ͣ͡͏͇̟͉̥͔̬̼͚͙͚B̛̜̮̤͓̝̪̪͈͕̘̜͙̰̮̫̘̣͓͔̅ͩ͊̔ͦͯ́̌́͆ͭ̓́e̶̢̡̦͇͕̙͈͖͕̦̬̫͕̣̺̒̿͂͐͒͋͂ͦ́͋ͤ̿ͬ̊ͣ͗̑̽͜ͅͅh̸͑ͫͧ̑ͬͧ̈́̎̃ͣ̊̾͂ͨͤ̓͐̐̑͏̸̭͓̘͉̩i̧̧̭̣͈̝̺̼̺̠͉̞̜̲̳͙̦͐̔ͯ͛̅̾n̸͓̝̤̙͙͔ͪ̋̈́͒̒ͭ̈́̓ͮ̋̀̋̀̈ͩ́͌̄͘d̷̫̳̩̼̥̗̲̰͇͉̼̬̤͇̖ͮ̿ͬ͂ͦ̏̓ͮ̽͂̾̾ͯ͆͜͠ ̨̈́͒̇̏̄̑̓ͮͥ̒ͤͨ̋҉̴̴̟̱͙̟̫̩̗͔̝͔̀Ţ̵̝̟̖̭͇̻̳͖͉̺̖̖͙͙̺̐̈́̓ͯ̆̇̋ͩ͊̄̾̾ͬ̌̚͟ͅh̡͈̗̜͙̬̗̲̦̲̟̗̦̬͓̳ͧ̋̌͂͂ͨͬͦ̿̏̈́̋ͣ̒̕͡ͅͅe̗͇̰̰̥̪̗͑̔̓́̈́ͨ̊́̿̅ͯͥ̈́͐͗͘͢͝ ̡̢̛̯͎͓̰̘͎̦̪̯̪̥̰̲͇̠̲͔ͤͤ̇̅̆̋̂̆̈́ͤ̿͑ͅW̡͓͈̲̲͉̜͔̖͈̻̱͚̿̌͗̉ͤ͢͡ͅͅa̔̾͛̅͊͋͐҉̱̹̬͍͙̻̱l̢͎̟̬̙̼̱̫̮̘̼͔̭̅ͬ͑ͣ̏̾̅̓ͣ̿ͣ̈́̕͢͡ͅͅl̡̥̣͔̭̇̒͛͒͐̄̽͛̋ͥ̌͢͟͡.̷̰̝̮͔̟̦͈̥̬̻̥̬͎͓̻̲̇ͮ̿ͨͦ̽ͫ͟͢͝͠\r
916 ̗̱͖͈͌̈ͦ͛ͮ̌͋̽̃͆̀͂ͨͧ̄̔̔ͭ̏͢Z̃̉̿ͮ̃̀͘͏͕̬̯̖͚̗͔Aͣ̑̈̓̈̑̈̀̿̚҉͙͍̦̗̦͙̠̝̩̯ͅͅL̴͖̞̞͙̱̻̥̬̜̦̐̇̉̈̽ͪ̅ͪ̂̔͌͑ͭ͐ͤ̈́̿̉͞ͅG̴̵̲̰̹̖͎͕ͯ̆̓̽͢͠Ŏ̶̡̺̼͙̣̞̩͕̥̟̝͕͔̯̞ͨ͒͊̂̊͂͗̒͆̾͆̌͆̃̎ͣͫ͜͡ͅ!̓̽̎̑̏́̓̓ͣ̀͏̱̩̭̣̹̺̗͜͞͞\r
917
918 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas sit\r
919 amet tellus nec turpis feugiat semper. Nam at nulla laoreet, finibus\r
920 eros sit amet, fringilla mauris. Fusce vestibulum nec ligula efficitur\r
921 laoreet. Nunc orci leo, varius eget ligula vulputate, consequat\r
922 eleifend nisi. Cras justo purus, imperdiet a augue malesuada, convallis\r
923 cursus libero. Fusce pretium arcu in elementum laoreet. Duis mauris\r
924 nulla, suscipit at est nec, malesuada pellentesque eros. Quisque semper\r
925 porta malesuada. Nunc hendrerit est ac faucibus mollis. Nam fermentum\r
926 id libero sed egestas. Duis a accumsan sapien. Nam neque diam, congue\r
927 non erat et, porta sagittis turpis. Vivamus vitae mauris sit amet massa\r
928 mollis molestie. Morbi scelerisque, augue id congue imperdiet, felis\r
929 lacus euismod dui, vitae facilisis massa dui quis sapien. Vivamus\r
930 hendrerit a urna a lobortis.\r
931
932 T̴̷͚͖̜͈̪͎͔̝̫̦̹͔̻̮͂ͬͬ̌ͣ̿ͤ͌ͥ͑̀̂ͬ̚͘͜͞ô̵͚̤̯̹͖͍̦̼̦̖̞̺͕̳̬͇͕̟̜̅̌̈́̑̏̕͘͝ ͍̼̗̫͈̭̦̱̬͚̱̞͓̜̭̼͇̰̞ͮ͗ͣ́ͪ̔ͪ̍̑̏́̀̽̍̔͘͜͜͝ȋ̐̽ͦ̓̔̅͏̧̢̖̭̝̳̹̯̤͈̫͔͔̠͓͉̠͖̠͜ͅn̷̯̗̗̠̱̥͕͉̥͉̳̫̙̅͗̌̒͂̏͑̎̌̌̊͌͘͘ͅͅv̧̜͕͍͙͍̬͕͍̳͉̠͍̹̮̻̜ͨ̏͒̍ͬ̈́͒̈ͥ͗ͣ̄̃ͤ͊̌͆̓o̸̧̎̓͂̊͢҉͍̼̘͇̱̪̠͎̥̹ķ̈́͗͆ͥ͐͑̆̎́͌ͩͯ̊̓͐ͬ̇̕҉̢͏͚̲̰̗̦e̿̀͐̽ͪ̈ͤͬ҉́͟͏̵̫̲̱̻̰̲̦͇̭̟̺͈̞̫̰̜͕͖ͅ ̡̰͎͓͚͓͉͈̮̻̣̮̟̩̬̮̈̋̊͆ͪ̄ͪ͒ͨͧ̇ͪ̇̑̚t̷̬̟͎̞͈̯͙̹̜ͩ̓ͪ͛͐̐ͤ̾̄̈͒̽̈́̑͒̏h̨̢̳͇͓͉̝ͫ̐̓̆̓ͮ̔̓̈́̇ͫe̟̬̣̗͚̬̾̉͋̽ͯ̌ͯͬ̂ͯͭ̓͛́̚͡ ̨̭̱͉̭͈̈̽̆̂͒͗̀ͥͩ͡h̻̼̱̹̗͖̙̗̲̤͓͇͚͚̻̞̥ͥ͛͌ͧ̚͟i̢̯̹̹̘̳̙ͩ̉ͥ͆̽̇̾̎͗̔̓͂͂́̓̌ͬv̧̡̛̟̜̠͉͖̘̲̻̯͚͍͓̯̻̲̹̥͇̻̿̓͛̊̌ͩͩ́ͩ̍͌̚e̵̾́̈́̏͌͌̊͗̏͋ͦ͘͡͏͚̜͚͎͉͍̱͙̖̹̣̘̥̤̹̟͠-̔̌͐́͒ͦͮ̇ͭ̄̏̊̇̍̕͏̩̥̰͚̟m̨̒ͫͦ̔̔͋҉̱̩̗͇̥̰̩̭͍͚͠į̵̷̻̗͉͕͚̣̼̺͉̦̮̠̆̀̐ͩ͒ͯͩͯ͞ͅn̢̫̤̝̝͚̺͍̱̦͚͂̿ͨ̇ͤ͠d̡ͯ͋̋ͧ̈́̒̈͏̛͏̵̤̬͍̗̞̠̟̞̺̠̥̹̱͉̜͍͎̤ ̷̸̢̰͓̘̯͎̤̫̘͓̙̟̳͇̹̥͈͙̮̩̅̋͌͗̓͊̓ͨͣ͗̓͐̈́ͩ̓ͣrͫ͂͌ͪ̏̐̍̾ͥ̓͗̈͆̈ͥ̀̾̚̚҉̴̶̭͇̗͙̘̯̦̭̮̪͚̥̙̯̠͙̪͡e̵̸̲͉̳̙͖͖̫̘̪͕̳͓̻̙͙ͥ̍͂̽ͨ̓̒̒̏ͬ͗ͧ̑̀͠p̵̸̛̦̣͙̳̳̩̣̼̘͈͂ͪͭͤ̎r̶̩̟̞̙͔̼ͫ̆ͦ̐̀̏̾̉̍ͬ̅ͧ͊ͪ̒̈́ͬ̃͞ẻ̴̼͙͍͎̠̀̅̔̃̒͐ͦ̏̆̅̓͋͢ͅš̆̈̆̋ͨ̅̍̇͂̒ͩͨ̂̐̓ͩ͏̸͔͔̯͇͚̤̪̬̗͈̰̦̯͚̕ę̢̱̠͙̲͉̗͚̮̪͖̙̞̦͉͕̗̳͙ͦ̆̋͌ͣ̅̊́ͅņ̴̷̫̪̦͇̺̹͉̗̬̞̲̭̜̪͒̏͂̂̎͊́̋͒̏̅̋̚͘t̷̶̨̟̦̗̦̱͌͌ͩ̀i̴̴̢̖͓͙̘͇̠̦̙̭̼͖̹̾̒̎̐ͥͭ͋ͥ̅͟ͅņ̫͙̹̦̳͈͙̬̫̮͕̰̩̣̘̘͐̀̓ͭͩͬͯ̎͛̿ͫ̊̔̅́̕͠gͥͩ̂͌̒̊̕͏̻͙͖̣͙͍̹͕̝͖̼̙̘͝ ͤ͐̓̒̓͋̐̃̇͊̓ͦ͐̚͢҉̢̨̟̠͉̳͖̲̩͙̕ć̷̡̫̩̞̯̼̝̼͖̤̳̻̘̪̤͈̦̭ͣ́͂͐̽͆̔̀̚͜h̶̢̹̹̙͔̱̓ͦ͌̋̎ͭ͒͋̒ͭ̌̃͌̿ͣ̆̅͑ą̙̳̬̞̬͚̜̤̱̙͇̠̟̈ͤ͋̃̀̓̓ͯ̍̀̽ͣ̐̈̿̌̕ǫ͋͂͐ͬ̿ͯ̂̈́͌̓̌ͧ̕͏̜͔̗͚͔̘̣͕̘̲͖̼͇͖̗̳ͅͅs̷̸̝̙̭̦̣̦̯̭̦͙̹̻͍͇̣̼͗̌͆ͨͭ̃ͮ͐̿̕.̮̝̠̱̺͖͓̼̦̱̉͂͛̓̑̔̓ͮ̈̊̔͗́͝\r
933 ̛̣̺̻̼̙̼͓̱̬͕̩͕̲̳̭̗̍ͤ͋̒̆̄ͨ̿ͧ̓͠ͅI̷̻̤̳̲͔͈̖̬̰͔̪͇͇̟̋ͨ̋̍̉̔͝͞͝ͅn̶͕̭͖̠̣͚̹̪͆ͪ̇̂̅̾ͫ́̅̉ͭ̀͜v̖͉̩͕̣͔̭͕̩̲̖̇̀ͬ́̄͒̆͑͆ͪͤ͆̾̍ͯ̚͜ǫ̡̡̫͎̟̞̰̞̹͇̲̏ͨ̄͊̊̇͒̽͢ķ̶̪̙̰̥͙̞̹̭̺͍͕̙̲̮͊ͭ́͋͛͋̑̒͊̏̒̅͛̄̓͟i̴͎̹̞̥͖̒̄ͮ̒̾ͮͧ̀̚͡n̸̵͓̲̟̞̳͚̼̣͙͖̈ͦ͒̿̅̒̿͛͊̇ͧ̉g̡̧̪̩͚͙͓̪͓͚͉̥̪͍̙̻͖͇͗̑͊͑̾̍͊̀ͅ ̷̵̠͚̘̟͓̫̣̲͎̩̹̣̼̟͊́̏ͫ̆ͩ̓͋͆̿̽̓͘̕t̴̢̝̻̖̲̬̜̺̖̻ͩ̿ͫ͗̈́̔͑̐ͮͦ̽̉̓̚͜h̷̛̲͇̫͈̣̭͂ͭ̂͋ͭ̋̔ͮ̆ͩ͞ë̩͕͉̯͇͔͚̭̼̮̣͓̯́ͭ̀ͣ͗̋̉ͨͬ̒ͥͩ͆̓̓́̀̚͘͝ ̛̫̠̗̥̳͇͉̟̮̪̻̤̪͚̟̜̔̌͌̈͌ͪ̋̎̄ͯ͐ͦ́͞͠fͦ̂̈ͬ̇̅̓̓ͫͣ̉̂̉̚͘͡͡͏̼̖̟͚̙̳͔͎̲̫̦̯͔̣̼̹ě̷̶̫͎̞̺̪̪͇͈̞̳̏̋̋͋̾̓̽̓̑ͮ͊ͣ̋̃̅̀͡e͇̗͎̱͔̦̠̰̩̩͖͙̠̻̝ͯ̿̔̀͋͑ͧ͊̆̇̿ͤ̄ͯ̇̀͢͠ͅl̂̿ͯ͛̊̒̓̈́͏̵̪̦̞̤̫̤͇̙̗͕͎̪͕̙̻̳̗̕͟͢i̞̣̙͎͈̗̮͉̱̜̱̝̞̤͋ͯ͋͐̈́ͫ̉̊̏̀ͯͨ͢͟͝n̳̻̼̥̖͍̭̅͂̓̔̔ͦ̔́ͦ͊̀͛̈́ͬͦ͢͡͡ģ̶̡̳̰̻̙̞̱̳̣̤̫̫͕̤̮̰̬̪̜͋͒̎̈́̉̏̀ͬͯ͌̇͊̚ ́̽ͤͦ̾̔͢҉̛̤͍͉̺̙̮̗̜̟̀͝ơ̢̱͓͓̙͉̖̠̯̦̗͍̓̐̃̉̅̃ͨ͆́ͪ̂̒̀̊̃͆̔͡͡ͅf́ͬ̊ͯͫ̉̈́̽̉̚͢͏̡̺̬̖͇̫͉̱ ̴͇̦̗̙̼̬͓̯͖̮͓͎̗͈̻̈́͆ͭ̐ͦ́͛̀͋̐̌ͬ͑̒̊̿̃͞c̶̸̣͔̬͕̪̱̩̣̑̒̑̓̍̓͂̍̔͌̚͘͜͞h̶͈̱͇͉̳͍͍̰͈͖̬̥͚̯͓̞̹̋̔ͯ̑̃́̒̎̎͊̈́̍̚̕ạ̴̞̱̥͍͙̺͉͚͎̫̦͎̥ͩ̀̀̊ͥ͢o̵̧͕̜͓͈̬̰̫̮͙̹͉̩̝̩͎̓̆͗̿̊̀ͯ̃ͪ̊ͫ̽̉̓ͧ͗́̚͢ͅͅs̡ͫ͋̑ͮ̍̃͊̄ͬ̅̈́ͬ̍̇̔̈̅̍̀҉̜͓̝̘̘̮̼͖͎̻͓͖̖͙̞ͅ.͗ͬͭͩ̌̅͗͏̷̮̗͇͔͇͈̮͢\r
934 ̨͚̲̫̠̼͖̝̻̉ͤ̅̂ͩ̀̇ͬͭ̀͜Ẅ̢́̉͌ͮͬͨ͊̏͌̇̐͊͟͠҉̼̰̦̩͇͕̟̭̪̲͕̥͖̰̪͈̀ͅͅį̷ͣͦ̉̍ͨ͂͂͑̃͂ͪ̊̈̋̄͜҉̨͚̟̲̯̹̺̝̭̺̙͖͍t̼͓̰̩͙̦͓̟͚͖̀ͯ͛̍̈́͑͂̍̋́h̛̼̺̘̥̠̼̼̭͙̮͚̱̍ͯ̓̃̐̂̇͟ ̴̛͖͔̰̠̺̥̲ͮ̍ͫ̽͜õ̒ͯ̒̓ͦ̈́͑̔̒̓̎ͤ͑҉̸̭̱̤̭̬͈ų̙̫̤͖̺̫̱͓͓̗̪͇̩̙̔̉̊͂ͪ̇͢͟͞ͅt̸̬̣̫̞̫̅͐ͮ̌͌̈́̀̀͘ ̷̴̨̖̙̹͚ͬ̈́̈ͯͨͮ̇̈́̋̈́ͭ͛̑̉͊̕ö̡̍ͥ̂ͬͪͧ͒ͧ̏̓̇̂̄͆̌ͫͤ͢͠͝͏̖̱̯̘͙̰̖͎̰͓̟̤ṙ̡̬̟̬̜̪̮̺͖̗̘͈̟ͨ͐͗̑͒̐d̢ͭͫ̊̏ͬͥ͋́̌̈́ͮ̆ͬ̐̌̎͏̵̷̡̞̲̹̙͕̮̮͚ḙ̴̸̠͔͎̥͇͖͕̘̍̓̏̐ͩͩ̈́ͦ̐̋ͤ̎̾̌̏͊̊́̚͞ͅr̸͈̗̣̲̗̣̬̤ͦ̎ͫ̏̀ͥͪ̋ͧ̄͑̋͒͌͋ͦ̉͟͞.ͨͣ̽̈́͒̄ͮ̀͋͋͏̴̧̯̺̙̱̻͙̜\r
935 ̡̣̞̠͓̰͍̠͕̭̺̼͊̽̿͊ͮ̐̓̒̊͒̔̓͐ͨ̈̌́T̸̸̓́̋ͬ́͆ͨͫ͌͂ͣ̋͒҉̺̝͎̟͖͚̠h̸̡̰̜̦͇͕̪̝̳͕͉̲̝̑ͥ͋ͧ̎̆͌͟e̛̹͍͍̫̙̞̪̭̙̟͙̱̺̮̳͕̜ͫ̓ͭ͊ͫ͆̀̚͟͡ ̿͂̄ͧ̔̎ͧ͑̾̀̓͏̦͍̳͈̳͔̘̖̲̯̰̟̝̳̖̦N̶̡̧̦̮̟̦̩̰̣̝̆̀͊̔͢e͛̄ͮͦͨ͂̔̓̍̄̉͆͊̑̑̆̚͏̜̗͎̝̼̯̥̜͖͍̪̝͞ͅͅz̨̛̀̾ͪ͗̉́͠͏͚̫̼̫̜̣pͪͦ͌̄ͥ̆ͣͩ͋̉́̏͞͏̥̜̝̳̱̞̙̳̤͙̟̟̮̦ȅ̷̩̟͉̯͕͔̘̺̥̻̻ͧ̊̅̽ͣ͑̓̑̽ͦ̾͌͜r̴̭̥̲̲̤͚͈̰͇̰͈̰̹ͫ̒ͯ̿͒ͧ̊͆͒ͣ́ḍ̭̟̤̈́̌̓̈́ͫ͐̍͂͞į̛̞̝̮̣͙͙̤̇̂̓̎͋̿̓̎̄̈́ͧ̓ͩ̐̓̄̋ͭ͞͠a͋̔̋ͫ̂͐͂҉̸̛̥̩̯̯̤̝͔̠̝̯̪̥̩̻̼̮n͌ͣ̂͋̿̚҉̛̙̲̺̯͇͓̝̯̪̟͔̩͟ͅ ̢̨͚̻̗̘͖̯̐ͥ͋̽ͯ̎̈́͋̏̄͋̆̑̊̆̚̕͟ͅh̢̛̗̱̭͇͖̰̮̮͈̲͍̯̟ͭ͊̎̽̓ͦͤ͠ï̛̘̝̦͎̦̭̠͖̳͎̮̼̏͐ͧ̒̒͐͑ͪͫ̋̽̚̚͜v̴̮͕̝̮̞͐̄͗̋͒ͤ̎̈̑ͬͮ̄̾ͤ̓̾͊͗͟é̶̷̡̩͖̰̫͓̟ͮͬͣ͊-ͦ͛ͩͤͨͨ̆̄͏̼̜̭͔̳͈͖̳̩͢ͅͅm̷̴̓́̓͛͒̾̍̉҉̛̗̹̠̣̪̺͎̖̝͚̖͙i̛̥͓̬̫͉͕͉͆͒ͧ̂̿̔̔͆̆̓̍͊̀͜n͌ͧͣ̅̌̎ͦͦ͑̑ͭ̆ͬ̀ͤ̀ͣ̚҉͎̰̱͚͈͈̬̹͕̺̙͙̼͘͘͞d̶͖̫̟̲͕̺̠͎̘͕̱̼͙̪̪̩͙̅̅̑̓̇͑̊̉͜͞ ̶̵̷̴̡̠͚̪͕̣̱̖̱̗̤̭̭͔͖͚ͧͤͥ͒̌ͪ͊͂͒̓͂ͧͧ̇̇͐̑̔ͅͅơ̵̲̲͇̯̰͇̜̣͕͕͓̲̤̲͔͚̞͑͗ͤ̓́̚͠ͅf̢̧̛̩̯̼̫͖̾ͣ͌̾̉́̈́̑̈́̚͞͞ͅ ͤͩ́͋͒ͫͬͣ̋̅̆҉̧̱̻͓͕͉̹̫̫̞̯̪̙̩͍̦͔̖̮̀͟ͅc͉̠̜̩̟͕͎̙̣̮̘̼͋ͯ̍ͨ̅̄ͫ̈̋ͫ̊͡͝ȟ̸̨ͯͦ̂̉̇̾̆ͭ̋̐̈̆̀̚͜҉͚͕̻̖a̶̴̛͚̗͙̳̬̲͚ͦ́̐ͥ́̔̅̑̎͐̑ͯ̾ͤͥͧ͡ò̶̧̞̪̦̥̪̻̦̝̳̬̔͛͛ͣ̋̌̔ͫ̂̽ͫ͘͠s̸̖̣̬̤̫͇̫̣̑͆͒̎̏́͟.̴̗̤̭͉̯̻̤͕̌ͯ̍ͤ̓͌ͤ̈̆̉ͦ̇́̚͘͟͝ͅ ̯̹̪͓̬͌̔̌ͬ̀͘͢͡͡Z̡̩̲̩̰̫̩̟͍̰͖͔̭ͣ̆̾ͭ̀́͞ͅa̡̡̙̜̭͇͎͔̙̞̫͓̜͉͔̬ͭ̈ͨ̉͆ͣͫ̃͌̓͌́ͣͥ̒̌͊͘͝l̢̨̡̯̙̫͖̫̺̘̬̟͈͌̊ͧͫͦ̉̃ͩͦ̒ͯ̇̌̓͛͟͝ͅg̵̙̼̼ͪ͂ͭ͗̈̕ȯ̅ͧ̓ͪ́̂͑̐ͩͥͬ̊̑͆̇͒ͫͣ͝҉͎̟̜̥͎̮̣͉̖̟̯̦̖͙͙͞ͅ.̈̑ͩ̇̂ͬ̓ͬ͊͂ͨ̽͠͏̺͎̞̦̜͍͚̯̯͔̝̞̻̩̖\r
936 ̷̰̪͍͎͔͒ͯͥ̾̉͆ͤ̊̓̂͋̀͆H̸̸̹̞̙̺͎̠̯̤ͨ̉̍ͬͤ̓̐͌ͥͮ͞eͣ̈̾͛́͏͕̗͍̜̼͎͚̟̬̣̝̕ͅͅ ̴̛̩̗̼̝̣̩͚͇̯́̉͋̂̍͂̌ͮ͋̾͜͠wͮ̽̓ͭ̿͐̽̐̽͆̓͝҉̡̼̲͖̪̥h̢̢̛͍̰̰̻̱̼̰̹̖̖̪̝̥̘̎̀ͪ͒̾ͫͬ̆̑o̡̗̠̞̱̥͎̰͎͍̫̻͓͇͓͐ͥͯ͂̅͠ͅ ̡̛̏͑ͦ̓͊ͮͫͯͭ̌͒̆̍̈͠҉͖͚̪̫̗̮W̴̐̊͋̾ͥͫ҉͎̞͔̯̫̹͖̰͉̹̼͎̰̱͓̻̀a̶̩̤̙̣͎̳̭̲̗̠͉̳̭̭̦̞͎̮̅͌̾͗̾͛̇̀́͟͞ͅi̷̡ͣ̆̌͋͒͒́͘͏̮̺̩͎͇̜͍̫ṯ̴̢͖̥̖͇͎̦̦̹̖͇̪ͭ̅̍͐̇͒͋̽̏̿̒͆ͧ̄͋ͧͩ͒͜s̙̥̖̘̖͚̭̤̮̖̘̰̫̟̈́ͣ̍ͧ͐ͥ̏͆̃̿͒̔͐́̚͟ͅ ̨ͭ̌ͬͯ͆̒͋ͭ̔̿ͧ̅̓ͣ͡͏͇̟͉̥͔̬̼͚͙͚B̛̜̮̤͓̝̪̪͈͕̘̜͙̰̮̫̘̣͓͔̅ͩ͊̔ͦͯ́̌́͆ͭ̓́e̶̢̡̦͇͕̙͈͖͕̦̬̫͕̣̺̒̿͂͐͒͋͂ͦ́͋ͤ̿ͬ̊ͣ͗̑̽͜ͅͅh̸͑ͫͧ̑ͬͧ̈́̎̃ͣ̊̾͂ͨͤ̓͐̐̑͏̸̭͓̘͉̩i̧̧̭̣͈̝̺̼̺̠͉̞̜̲̳͙̦͐̔ͯ͛̅̾n̸͓̝̤̙͙͔ͪ̋̈́͒̒ͭ̈́̓ͮ̋̀̋̀̈ͩ́͌̄͘d̷̫̳̩̼̥̗̲̰͇͉̼̬̤͇̖ͮ̿ͬ͂ͦ̏̓ͮ̽͂̾̾ͯ͆͜͠ ̨̈́͒̇̏̄̑̓ͮͥ̒ͤͨ̋҉̴̴̟̱͙̟̫̩̗͔̝͔̀Ţ̵̝̟̖̭͇̻̳͖͉̺̖̖͙͙̺̐̈́̓ͯ̆̇̋ͩ͊̄̾̾ͬ̌̚͟ͅh̡͈̗̜͙̬̗̲̦̲̟̗̦̬͓̳ͧ̋̌͂͂ͨͬͦ̿̏̈́̋ͣ̒̕͡ͅͅe̗͇̰̰̥̪̗͑̔̓́̈́ͨ̊́̿̅ͯͥ̈́͐͗͘͢͝ ̡̢̛̯͎͓̰̘͎̦̪̯̪̥̰̲͇̠̲͔ͤͤ̇̅̆̋̂̆̈́ͤ̿͑ͅW̡͓͈̲̲͉̜͔̖͈̻̱͚̿̌͗̉ͤ͢͡ͅͅa̔̾͛̅͊͋͐҉̱̹̬͍͙̻̱l̢͎̟̬̙̼̱̫̮̘̼͔̭̅ͬ͑ͣ̏̾̅̓ͣ̿ͣ̈́̕͢͡ͅͅl̡̥̣͔̭̇̒͛͒͐̄̽͛̋ͥ̌͢͟͡.̷̰̝̮͔̟̦͈̥̬̻̥̬͎͓̻̲̇ͮ̿ͨͦ̽ͫ͟͢͝͠\r
937 ̗̱͖͈͌̈ͦ͛ͮ̌͋̽̃͆̀͂ͨͧ̄̔̔ͭ̏͢Z̃̉̿ͮ̃̀͘͏͕̬̯̖͚̗͔Aͣ̑̈̓̈̑̈̀̿̚҉͙͍̦̗̦͙̠̝̩̯ͅͅL̴͖̞̞͙̱̻̥̬̜̦̐̇̉̈̽ͪ̅ͪ̂̔͌͑ͭ͐ͤ̈́̿̉͞ͅG̴̵̲̰̹̖͎͕ͯ̆̓̽͢͠Ŏ̶̡̺̼͙̣̞̩͕̥̟̝͕͔̯̞ͨ͒͊̂̊͂͗̒͆̾͆̌͆̃̎ͣͫ͜͡ͅ!̓̽̎̑̏́̓̓ͣ̀͏̱̩̭̣̹̺̗͜͞͞\r
938
939 Pellentesque nec viverra metus. Sed aliquet pellentesque scelerisque.\r
940 Duis efficitur erat sit amet dui maximus egestas. Nullam blandit ante\r
941 tortor. Suspendisse vitae consectetur sem, at sollicitudin neque.\r
942 Suspendisse sodales faucibus eros vitae pellentesque. Cras non quam\r
943 dictum, pellentesque urna in, ornare erat. Praesent leo est, aliquet et\r
944 euismod non, hendrerit sed urna. Sed convallis porttitor est, vel\r
945 aliquet felis cursus ac. Vivamus feugiat eget nisi eu molestie.\r
946 Phasellus tincidunt nisl eget molestie consectetur. Phasellus vitae ex\r
947 ut odio sollicitudin vulputate. Sed et nulla accumsan, eleifend arcu\r
948 eget, gravida neque. Donec sit amet tincidunt eros. Ut in volutpat\r
949 ante.\r
950
951 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas sit\r
952 amet tellus nec turpis feugiat semper. Nam at nulla laoreet, finibus\r
953 eros sit amet, fringilla mauris. Fusce vestibulum nec ligula efficitur\r
954 laoreet. Nunc orci leo, varius eget ligula vulputate, consequat\r
955 eleifend nisi. Cras justo purus, imperdiet a augue malesuada, convallis\r
956 cursus libero. Fusce pretium arcu in elementum laoreet. Duis mauris\r
957 nulla, suscipit at est nec, malesuada pellentesque eros. Quisque semper\r
958 porta malesuada. Nunc hendrerit est ac faucibus mollis. Nam fermentum\r
959 id libero sed egestas. Duis a accumsan sapien. Nam neque diam, congue\r
960 non erat et, porta sagittis turpis. Vivamus vitae mauris sit amet massa\r
961 mollis molestie. Morbi scelerisque, augue id congue imperdiet, felis\r
962 lacus euismod dui, vitae facilisis massa dui quis sapien. Vivamus\r
963 hendrerit a urna a lobortis.\r
964
965 T̴̷͚͖̜͈̪͎͔̝̫̦̹͔̻̮͂ͬͬ̌ͣ̿ͤ͌ͥ͑̀̂ͬ̚͘͜͞ô̵͚̤̯̹͖͍̦̼̦̖̞̺͕̳̬͇͕̟̜̅̌̈́̑̏̕͘͝ ͍̼̗̫͈̭̦̱̬͚̱̞͓̜̭̼͇̰̞ͮ͗ͣ́ͪ̔ͪ̍̑̏́̀̽̍̔͘͜͜͝ȋ̐̽ͦ̓̔̅͏̧̢̖̭̝̳̹̯̤͈̫͔͔̠͓͉̠͖̠͜ͅn̷̯̗̗̠̱̥͕͉̥͉̳̫̙̅͗̌̒͂̏͑̎̌̌̊͌͘͘ͅͅv̧̜͕͍͙͍̬͕͍̳͉̠͍̹̮̻̜ͨ̏͒̍ͬ̈́͒̈ͥ͗ͣ̄̃ͤ͊̌͆̓o̸̧̎̓͂̊͢҉͍̼̘͇̱̪̠͎̥̹ķ̈́͗͆ͥ͐͑̆̎́͌ͩͯ̊̓͐ͬ̇̕҉̢͏͚̲̰̗̦e̿̀͐̽ͪ̈ͤͬ҉́͟͏̵̫̲̱̻̰̲̦͇̭̟̺͈̞̫̰̜͕͖ͅ ̡̰͎͓͚͓͉͈̮̻̣̮̟̩̬̮̈̋̊͆ͪ̄ͪ͒ͨͧ̇ͪ̇̑̚t̷̬̟͎̞͈̯͙̹̜ͩ̓ͪ͛͐̐ͤ̾̄̈͒̽̈́̑͒̏h̨̢̳͇͓͉̝ͫ̐̓̆̓ͮ̔̓̈́̇ͫe̟̬̣̗͚̬̾̉͋̽ͯ̌ͯͬ̂ͯͭ̓͛́̚͡ ̨̭̱͉̭͈̈̽̆̂͒͗̀ͥͩ͡h̻̼̱̹̗͖̙̗̲̤͓͇͚͚̻̞̥ͥ͛͌ͧ̚͟i̢̯̹̹̘̳̙ͩ̉ͥ͆̽̇̾̎͗̔̓͂͂́̓̌ͬv̧̡̛̟̜̠͉͖̘̲̻̯͚͍͓̯̻̲̹̥͇̻̿̓͛̊̌ͩͩ́ͩ̍͌̚e̵̾́̈́̏͌͌̊͗̏͋ͦ͘͡͏͚̜͚͎͉͍̱͙̖̹̣̘̥̤̹̟͠-̔̌͐́͒ͦͮ̇ͭ̄̏̊̇̍̕͏̩̥̰͚̟m̨̒ͫͦ̔̔͋҉̱̩̗͇̥̰̩̭͍͚͠į̵̷̻̗͉͕͚̣̼̺͉̦̮̠̆̀̐ͩ͒ͯͩͯ͞ͅn̢̫̤̝̝͚̺͍̱̦͚͂̿ͨ̇ͤ͠d̡ͯ͋̋ͧ̈́̒̈͏̛͏̵̤̬͍̗̞̠̟̞̺̠̥̹̱͉̜͍͎̤ ̷̸̢̰͓̘̯͎̤̫̘͓̙̟̳͇̹̥͈͙̮̩̅̋͌͗̓͊̓ͨͣ͗̓͐̈́ͩ̓ͣrͫ͂͌ͪ̏̐̍̾ͥ̓͗̈͆̈ͥ̀̾̚̚҉̴̶̭͇̗͙̘̯̦̭̮̪͚̥̙̯̠͙̪͡e̵̸̲͉̳̙͖͖̫̘̪͕̳͓̻̙͙ͥ̍͂̽ͨ̓̒̒̏ͬ͗ͧ̑̀͠p̵̸̛̦̣͙̳̳̩̣̼̘͈͂ͪͭͤ̎r̶̩̟̞̙͔̼ͫ̆ͦ̐̀̏̾̉̍ͬ̅ͧ͊ͪ̒̈́ͬ̃͞ẻ̴̼͙͍͎̠̀̅̔̃̒͐ͦ̏̆̅̓͋͢ͅš̆̈̆̋ͨ̅̍̇͂̒ͩͨ̂̐̓ͩ͏̸͔͔̯͇͚̤̪̬̗͈̰̦̯͚̕ę̢̱̠͙̲͉̗͚̮̪͖̙̞̦͉͕̗̳͙ͦ̆̋͌ͣ̅̊́ͅņ̴̷̫̪̦͇̺̹͉̗̬̞̲̭̜̪͒̏͂̂̎͊́̋͒̏̅̋̚͘t̷̶̨̟̦̗̦̱͌͌ͩ̀i̴̴̢̖͓͙̘͇̠̦̙̭̼͖̹̾̒̎̐ͥͭ͋ͥ̅͟ͅņ̫͙̹̦̳͈͙̬̫̮͕̰̩̣̘̘͐̀̓ͭͩͬͯ̎͛̿ͫ̊̔̅́̕͠gͥͩ̂͌̒̊̕͏̻͙͖̣͙͍̹͕̝͖̼̙̘͝ ͤ͐̓̒̓͋̐̃̇͊̓ͦ͐̚͢҉̢̨̟̠͉̳͖̲̩͙̕ć̷̡̫̩̞̯̼̝̼͖̤̳̻̘̪̤͈̦̭ͣ́͂͐̽͆̔̀̚͜h̶̢̹̹̙͔̱̓ͦ͌̋̎ͭ͒͋̒ͭ̌̃͌̿ͣ̆̅͑ą̙̳̬̞̬͚̜̤̱̙͇̠̟̈ͤ͋̃̀̓̓ͯ̍̀̽ͣ̐̈̿̌̕ǫ͋͂͐ͬ̿ͯ̂̈́͌̓̌ͧ̕͏̜͔̗͚͔̘̣͕̘̲͖̼͇͖̗̳ͅͅs̷̸̝̙̭̦̣̦̯̭̦͙̹̻͍͇̣̼͗̌͆ͨͭ̃ͮ͐̿̕.̮̝̠̱̺͖͓̼̦̱̉͂͛̓̑̔̓ͮ̈̊̔͗́͝\r
966 ̛̣̺̻̼̙̼͓̱̬͕̩͕̲̳̭̗̍ͤ͋̒̆̄ͨ̿ͧ̓͠ͅI̷̻̤̳̲͔͈̖̬̰͔̪͇͇̟̋ͨ̋̍̉̔͝͞͝ͅn̶͕̭͖̠̣͚̹̪͆ͪ̇̂̅̾ͫ́̅̉ͭ̀͜v̖͉̩͕̣͔̭͕̩̲̖̇̀ͬ́̄͒̆͑͆ͪͤ͆̾̍ͯ̚͜ǫ̡̡̫͎̟̞̰̞̹͇̲̏ͨ̄͊̊̇͒̽͢ķ̶̪̙̰̥͙̞̹̭̺͍͕̙̲̮͊ͭ́͋͛͋̑̒͊̏̒̅͛̄̓͟i̴͎̹̞̥͖̒̄ͮ̒̾ͮͧ̀̚͡n̸̵͓̲̟̞̳͚̼̣͙͖̈ͦ͒̿̅̒̿͛͊̇ͧ̉g̡̧̪̩͚͙͓̪͓͚͉̥̪͍̙̻͖͇͗̑͊͑̾̍͊̀ͅ ̷̵̠͚̘̟͓̫̣̲͎̩̹̣̼̟͊́̏ͫ̆ͩ̓͋͆̿̽̓͘̕t̴̢̝̻̖̲̬̜̺̖̻ͩ̿ͫ͗̈́̔͑̐ͮͦ̽̉̓̚͜h̷̛̲͇̫͈̣̭͂ͭ̂͋ͭ̋̔ͮ̆ͩ͞ë̩͕͉̯͇͔͚̭̼̮̣͓̯́ͭ̀ͣ͗̋̉ͨͬ̒ͥͩ͆̓̓́̀̚͘͝ ̛̫̠̗̥̳͇͉̟̮̪̻̤̪͚̟̜̔̌͌̈͌ͪ̋̎̄ͯ͐ͦ́͞͠fͦ̂̈ͬ̇̅̓̓ͫͣ̉̂̉̚͘͡͡͏̼̖̟͚̙̳͔͎̲̫̦̯͔̣̼̹ě̷̶̫͎̞̺̪̪͇͈̞̳̏̋̋͋̾̓̽̓̑ͮ͊ͣ̋̃̅̀͡e͇̗͎̱͔̦̠̰̩̩͖͙̠̻̝ͯ̿̔̀͋͑ͧ͊̆̇̿ͤ̄ͯ̇̀͢͠ͅl̂̿ͯ͛̊̒̓̈́͏̵̪̦̞̤̫̤͇̙̗͕͎̪͕̙̻̳̗̕͟͢i̞̣̙͎͈̗̮͉̱̜̱̝̞̤͋ͯ͋͐̈́ͫ̉̊̏̀ͯͨ͢͟͝n̳̻̼̥̖͍̭̅͂̓̔̔ͦ̔́ͦ͊̀͛̈́ͬͦ͢͡͡ģ̶̡̳̰̻̙̞̱̳̣̤̫̫͕̤̮̰̬̪̜͋͒̎̈́̉̏̀ͬͯ͌̇͊̚ ́̽ͤͦ̾̔͢҉̛̤͍͉̺̙̮̗̜̟̀͝ơ̢̱͓͓̙͉̖̠̯̦̗͍̓̐̃̉̅̃ͨ͆́ͪ̂̒̀̊̃͆̔͡͡ͅf́ͬ̊ͯͫ̉̈́̽̉̚͢͏̡̺̬̖͇̫͉̱ ̴͇̦̗̙̼̬͓̯͖̮͓͎̗͈̻̈́͆ͭ̐ͦ́͛̀͋̐̌ͬ͑̒̊̿̃͞c̶̸̣͔̬͕̪̱̩̣̑̒̑̓̍̓͂̍̔͌̚͘͜͞h̶͈̱͇͉̳͍͍̰͈͖̬̥͚̯͓̞̹̋̔ͯ̑̃́̒̎̎͊̈́̍̚̕ạ̴̞̱̥͍͙̺͉͚͎̫̦͎̥ͩ̀̀̊ͥ͢o̵̧͕̜͓͈̬̰̫̮͙̹͉̩̝̩͎̓̆͗̿̊̀ͯ̃ͪ̊ͫ̽̉̓ͧ͗́̚͢ͅͅs̡ͫ͋̑ͮ̍̃͊̄ͬ̅̈́ͬ̍̇̔̈̅̍̀҉̜͓̝̘̘̮̼͖͎̻͓͖̖͙̞ͅ.͗ͬͭͩ̌̅͗͏̷̮̗͇͔͇͈̮͢\r
967 ̨͚̲̫̠̼͖̝̻̉ͤ̅̂ͩ̀̇ͬͭ̀͜Ẅ̢́̉͌ͮͬͨ͊̏͌̇̐͊͟͠҉̼̰̦̩͇͕̟̭̪̲͕̥͖̰̪͈̀ͅͅį̷ͣͦ̉̍ͨ͂͂͑̃͂ͪ̊̈̋̄͜҉̨͚̟̲̯̹̺̝̭̺̙͖͍t̼͓̰̩͙̦͓̟͚͖̀ͯ͛̍̈́͑͂̍̋́h̛̼̺̘̥̠̼̼̭͙̮͚̱̍ͯ̓̃̐̂̇͟ ̴̛͖͔̰̠̺̥̲ͮ̍ͫ̽͜õ̒ͯ̒̓ͦ̈́͑̔̒̓̎ͤ͑҉̸̭̱̤̭̬͈ų̙̫̤͖̺̫̱͓͓̗̪͇̩̙̔̉̊͂ͪ̇͢͟͞ͅt̸̬̣̫̞̫̅͐ͮ̌͌̈́̀̀͘ ̷̴̨̖̙̹͚ͬ̈́̈ͯͨͮ̇̈́̋̈́ͭ͛̑̉͊̕ö̡̍ͥ̂ͬͪͧ͒ͧ̏̓̇̂̄͆̌ͫͤ͢͠͝͏̖̱̯̘͙̰̖͎̰͓̟̤ṙ̡̬̟̬̜̪̮̺͖̗̘͈̟ͨ͐͗̑͒̐d̢ͭͫ̊̏ͬͥ͋́̌̈́ͮ̆ͬ̐̌̎͏̵̷̡̞̲̹̙͕̮̮͚ḙ̴̸̠͔͎̥͇͖͕̘̍̓̏̐ͩͩ̈́ͦ̐̋ͤ̎̾̌̏͊̊́̚͞ͅr̸͈̗̣̲̗̣̬̤ͦ̎ͫ̏̀ͥͪ̋ͧ̄͑̋͒͌͋ͦ̉͟͞.ͨͣ̽̈́͒̄ͮ̀͋͋͏̴̧̯̺̙̱̻͙̜\r
968 ̡̣̞̠͓̰͍̠͕̭̺̼͊̽̿͊ͮ̐̓̒̊͒̔̓͐ͨ̈̌́T̸̸̓́̋ͬ́͆ͨͫ͌͂ͣ̋͒҉̺̝͎̟͖͚̠h̸̡̰̜̦͇͕̪̝̳͕͉̲̝̑ͥ͋ͧ̎̆͌͟e̛̹͍͍̫̙̞̪̭̙̟͙̱̺̮̳͕̜ͫ̓ͭ͊ͫ͆̀̚͟͡ ̿͂̄ͧ̔̎ͧ͑̾̀̓͏̦͍̳͈̳͔̘̖̲̯̰̟̝̳̖̦N̶̡̧̦̮̟̦̩̰̣̝̆̀͊̔͢e͛̄ͮͦͨ͂̔̓̍̄̉͆͊̑̑̆̚͏̜̗͎̝̼̯̥̜͖͍̪̝͞ͅͅz̨̛̀̾ͪ͗̉́͠͏͚̫̼̫̜̣pͪͦ͌̄ͥ̆ͣͩ͋̉́̏͞͏̥̜̝̳̱̞̙̳̤͙̟̟̮̦ȅ̷̩̟͉̯͕͔̘̺̥̻̻ͧ̊̅̽ͣ͑̓̑̽ͦ̾͌͜r̴̭̥̲̲̤͚͈̰͇̰͈̰̹ͫ̒ͯ̿͒ͧ̊͆͒ͣ́ḍ̭̟̤̈́̌̓̈́ͫ͐̍͂͞į̛̞̝̮̣͙͙̤̇̂̓̎͋̿̓̎̄̈́ͧ̓ͩ̐̓̄̋ͭ͞͠a͋̔̋ͫ̂͐͂҉̸̛̥̩̯̯̤̝͔̠̝̯̪̥̩̻̼̮n͌ͣ̂͋̿̚҉̛̙̲̺̯͇͓̝̯̪̟͔̩͟ͅ ̢̨͚̻̗̘͖̯̐ͥ͋̽ͯ̎̈́͋̏̄͋̆̑̊̆̚̕͟ͅh̢̛̗̱̭͇͖̰̮̮͈̲͍̯̟ͭ͊̎̽̓ͦͤ͠ï̛̘̝̦͎̦̭̠͖̳͎̮̼̏͐ͧ̒̒͐͑ͪͫ̋̽̚̚͜v̴̮͕̝̮̞͐̄͗̋͒ͤ̎̈̑ͬͮ̄̾ͤ̓̾͊͗͟é̶̷̡̩͖̰̫͓̟ͮͬͣ͊-ͦ͛ͩͤͨͨ̆̄͏̼̜̭͔̳͈͖̳̩͢ͅͅm̷̴̓́̓͛͒̾̍̉҉̛̗̹̠̣̪̺͎̖̝͚̖͙i̛̥͓̬̫͉͕͉͆͒ͧ̂̿̔̔͆̆̓̍͊̀͜n͌ͧͣ̅̌̎ͦͦ͑̑ͭ̆ͬ̀ͤ̀ͣ̚҉͎̰̱͚͈͈̬̹͕̺̙͙̼͘͘͞d̶͖̫̟̲͕̺̠͎̘͕̱̼͙̪̪̩͙̅̅̑̓̇͑̊̉͜͞ ̶̵̷̴̡̠͚̪͕̣̱̖̱̗̤̭̭͔͖͚ͧͤͥ͒̌ͪ͊͂͒̓͂ͧͧ̇̇͐̑̔ͅͅơ̵̲̲͇̯̰͇̜̣͕͕͓̲̤̲͔͚̞͑͗ͤ̓́̚͠ͅf̢̧̛̩̯̼̫͖̾ͣ͌̾̉́̈́̑̈́̚͞͞ͅ ͤͩ́͋͒ͫͬͣ̋̅̆҉̧̱̻͓͕͉̹̫̫̞̯̪̙̩͍̦͔̖̮̀͟ͅc͉̠̜̩̟͕͎̙̣̮̘̼͋ͯ̍ͨ̅̄ͫ̈̋ͫ̊͡͝ȟ̸̨ͯͦ̂̉̇̾̆ͭ̋̐̈̆̀̚͜҉͚͕̻̖a̶̴̛͚̗͙̳̬̲͚ͦ́̐ͥ́̔̅̑̎͐̑ͯ̾ͤͥͧ͡ò̶̧̞̪̦̥̪̻̦̝̳̬̔͛͛ͣ̋̌̔ͫ̂̽ͫ͘͠s̸̖̣̬̤̫͇̫̣̑͆͒̎̏́͟.̴̗̤̭͉̯̻̤͕̌ͯ̍ͤ̓͌ͤ̈̆̉ͦ̇́̚͘͟͝ͅ ̯̹̪͓̬͌̔̌ͬ̀͘͢͡͡Z̡̩̲̩̰̫̩̟͍̰͖͔̭ͣ̆̾ͭ̀́͞ͅa̡̡̙̜̭͇͎͔̙̞̫͓̜͉͔̬ͭ̈ͨ̉͆ͣͫ̃͌̓͌́ͣͥ̒̌͊͘͝l̢̨̡̯̙̫͖̫̺̘̬̟͈͌̊ͧͫͦ̉̃ͩͦ̒ͯ̇̌̓͛͟͝ͅg̵̙̼̼ͪ͂ͭ͗̈̕ȯ̅ͧ̓ͪ́̂͑̐ͩͥͬ̊̑͆̇͒ͫͣ͝҉͎̟̜̥͎̮̣͉̖̟̯̦̖͙͙͞ͅ.̈̑ͩ̇̂ͬ̓ͬ͊͂ͨ̽͠͏̺͎̞̦̜͍͚̯̯͔̝̞̻̩̖\r
969 ̷̰̪͍͎͔͒ͯͥ̾̉͆ͤ̊̓̂͋̀͆H̸̸̹̞̙̺͎̠̯̤ͨ̉̍ͬͤ̓̐͌ͥͮ͞eͣ̈̾͛́͏͕̗͍̜̼͎͚̟̬̣̝̕ͅͅ ̴̛̩̗̼̝̣̩͚͇̯́̉͋̂̍͂̌ͮ͋̾͜͠wͮ̽̓ͭ̿͐̽̐̽͆̓͝҉̡̼̲͖̪̥h̢̢̛͍̰̰̻̱̼̰̹̖̖̪̝̥̘̎̀ͪ͒̾ͫͬ̆̑o̡̗̠̞̱̥͎̰͎͍̫̻͓͇͓͐ͥͯ͂̅͠ͅ ̡̛̏͑ͦ̓͊ͮͫͯͭ̌͒̆̍̈͠҉͖͚̪̫̗̮W̴̐̊͋̾ͥͫ҉͎̞͔̯̫̹͖̰͉̹̼͎̰̱͓̻̀a̶̩̤̙̣͎̳̭̲̗̠͉̳̭̭̦̞͎̮̅͌̾͗̾͛̇̀́͟͞ͅi̷̡ͣ̆̌͋͒͒́͘͏̮̺̩͎͇̜͍̫ṯ̴̢͖̥̖͇͎̦̦̹̖͇̪ͭ̅̍͐̇͒͋̽̏̿̒͆ͧ̄͋ͧͩ͒͜s̙̥̖̘̖͚̭̤̮̖̘̰̫̟̈́ͣ̍ͧ͐ͥ̏͆̃̿͒̔͐́̚͟ͅ ̨ͭ̌ͬͯ͆̒͋ͭ̔̿ͧ̅̓ͣ͡͏͇̟͉̥͔̬̼͚͙͚B̛̜̮̤͓̝̪̪͈͕̘̜͙̰̮̫̘̣͓͔̅ͩ͊̔ͦͯ́̌́͆ͭ̓́e̶̢̡̦͇͕̙͈͖͕̦̬̫͕̣̺̒̿͂͐͒͋͂ͦ́͋ͤ̿ͬ̊ͣ͗̑̽͜ͅͅh̸͑ͫͧ̑ͬͧ̈́̎̃ͣ̊̾͂ͨͤ̓͐̐̑͏̸̭͓̘͉̩i̧̧̭̣͈̝̺̼̺̠͉̞̜̲̳͙̦͐̔ͯ͛̅̾n̸͓̝̤̙͙͔ͪ̋̈́͒̒ͭ̈́̓ͮ̋̀̋̀̈ͩ́͌̄͘d̷̫̳̩̼̥̗̲̰͇͉̼̬̤͇̖ͮ̿ͬ͂ͦ̏̓ͮ̽͂̾̾ͯ͆͜͠ ̨̈́͒̇̏̄̑̓ͮͥ̒ͤͨ̋҉̴̴̟̱͙̟̫̩̗͔̝͔̀Ţ̵̝̟̖̭͇̻̳͖͉̺̖̖͙͙̺̐̈́̓ͯ̆̇̋ͩ͊̄̾̾ͬ̌̚͟ͅh̡͈̗̜͙̬̗̲̦̲̟̗̦̬͓̳ͧ̋̌͂͂ͨͬͦ̿̏̈́̋ͣ̒̕͡ͅͅe̗͇̰̰̥̪̗͑̔̓́̈́ͨ̊́̿̅ͯͥ̈́͐͗͘͢͝ ̡̢̛̯͎͓̰̘͎̦̪̯̪̥̰̲͇̠̲͔ͤͤ̇̅̆̋̂̆̈́ͤ̿͑ͅW̡͓͈̲̲͉̜͔̖͈̻̱͚̿̌͗̉ͤ͢͡ͅͅa̔̾͛̅͊͋͐҉̱̹̬͍͙̻̱l̢͎̟̬̙̼̱̫̮̘̼͔̭̅ͬ͑ͣ̏̾̅̓ͣ̿ͣ̈́̕͢͡ͅͅl̡̥̣͔̭̇̒͛͒͐̄̽͛̋ͥ̌͢͟͡.̷̰̝̮͔̟̦͈̥̬̻̥̬͎͓̻̲̇ͮ̿ͨͦ̽ͫ͟͢͝͠\r
970 ̗̱͖͈͌̈ͦ͛ͮ̌͋̽̃͆̀͂ͨͧ̄̔̔ͭ̏͢Z̃̉̿ͮ̃̀͘͏͕̬̯̖͚̗͔Aͣ̑̈̓̈̑̈̀̿̚҉͙͍̦̗̦͙̠̝̩̯ͅͅL̴͖̞̞͙̱̻̥̬̜̦̐̇̉̈̽ͪ̅ͪ̂̔͌͑ͭ͐ͤ̈́̿̉͞ͅG̴̵̲̰̹̖͎͕ͯ̆̓̽͢͠Ŏ̶̡̺̼͙̣̞̩͕̥̟̝͕͔̯̞ͨ͒͊̂̊͂͗̒͆̾͆̌͆̃̎ͣͫ͜͡ͅ!̓̽̎̑̏́̓̓ͣ̀͏̱̩̭̣̹̺̗͜͞͞\r
971
972 Aliquam finibus metus commodo sem egestas, non mollis odio pretium.\r
973 Aenean ex lectus, rutrum nec laoreet at, posuere sit amet lacus. Nulla\r
974 eros augue, vehicula et molestie accumsan, dictum vel odio. In quis\r
975 risus finibus, pellentesque ipsum blandit, volutpat diam. Etiam\r
976 suscipit varius mollis. Proin vel luctus nisi, ac ornare justo. Integer\r
977 porttitor quam magna. Donec vitae metus tempor, ultricies risus in,\r
978 dictum erat. Integer porttitor faucibus vestibulum. Class aptent taciti\r
979 sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.\r
980 Vestibulum ante ipsum primis in faucibus orci luctus et ultrices\r
981 posuere cubilia Curae; Nam semper congue ante, a ultricies velit\r
982 venenatis vitae. Proin non neque sit amet ex commodo congue non nec\r
983 elit. Nullam vel dignissim ipsum. Duis sed lobortis ante. Aenean\r
984 feugiat rutrum magna ac luctus.\r
985
986 Ut imperdiet non ante sit amet rutrum. Cras vel massa eget nisl gravida\r
987 auctor. Nulla bibendum ut tellus ut rutrum. Quisque malesuada lacinia\r
988 felis, vitae semper elit. Praesent sit amet velit imperdiet, lobortis\r
989 nunc at, faucibus tellus. Nullam porttitor augue mauris, a dapibus\r
990 tellus ultricies et. Fusce aliquet nec velit in mattis. Sed mi ante,\r
991 lacinia eget ornare vel, faucibus at metus.\r
992
993 Pellentesque nec viverra metus. Sed aliquet pellentesque scelerisque.\r
994 Duis efficitur erat sit amet dui maximus egestas. Nullam blandit ante\r
995 tortor. Suspendisse vitae consectetur sem, at sollicitudin neque.\r
996 Suspendisse sodales faucibus eros vitae pellentesque. Cras non quam\r
997 dictum, pellentesque urna in, ornare erat. Praesent leo est, aliquet et\r
998 euismod non, hendrerit sed urna. Sed convallis porttitor est, vel\r
999 aliquet felis cursus ac. Vivamus feugiat eget nisi eu molestie.\r
1000 Phasellus tincidunt nisl eget molestie consectetur. Phasellus vitae ex\r
1001 ut odio sollicitudin vulputate. Sed et nulla accumsan, eleifend arcu\r
1002 eget, gravida neque. Donec sit amet tincidunt eros. Ut in volutpat\r
1003 ante.\r
1004 ";
1005