// ABC 155-C
// 2020.2.16 bal4u

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef long long ll;

#define gc() getchar_unlocked()
#define pc(c) putchar_unlocked(c)

int in() {   // 非負整数の入力
	int n = 0;
	int c = gc();
	do n = 10 * n + (c & 0xf); while ((c = gc()) >= '0');
	return n;
}

ll ins() { // 文字列の入力　スペース以下の文字で入力終了
    ll n = 0;
	int c = gc();
    int w = 10;
	do n = (n << 5) + (c - 'a'+1), --w;
    while ((c = gc()) > ' ');
    return n << 5*w;
}

void outs(ll s) {
    int c, i = 5*9;
    while (c = (s >> i) & 31) pc(c+'a'-1), i -= 5;
    pc('\n');
}

void Usort(ll *a, int n) {
	int i, k;
#define B 8
#define BMSK 255 // (1<<8)-1
	int t1[1 << B], t2[1 << B];

	ll *tmp = malloc(n * sizeof(ll));
	for (k = 0; k < 8; ++k) {  // for 64ビット
		memset(t1, 0, sizeof(t1)), memset(t2, 0, sizeof(t2));
		for (i = 0; i < n; ++i)	t1[(a[i] >> k*B) & BMSK]++;
		for (i = 0; i < BMSK; ++i) t1[i+1] += t1[i];
		i = n; while (i--) tmp[--t1[(a[i] >> k*B) & BMSK]] = a[i];
		k++;
		for (i = 0; i < n; ++i) t2[(tmp[i] >> k*B) & BMSK]++;
		for (i = 0; i < BMSK; ++i) t2[i+1] += t2[i];
		i = n; while (i--) a[--t2[(tmp[i] >> k*B) & BMSK]] = tmp[i];
	}
	free(tmp);
#undef B
}

#define MAX 200005
ll s[MAX]; int N;
ll ans[MAX]; int M;

int main()
{
	int i, k, ma;

    N = in();
	for (i = 0; i < N; ++i) s[i] = ins();
	Usort(s, N);

	M = 0, k = 1, ma = 0;
	for (i = 1; i <= N; ++i) {
		if (s[i] == s[i-1]) ++k;
		else {
			if (k > ma) M = 0, ma = k;
			if (k == ma) ans[M++] = s[i-1];
			k = 1;
		}
	}
//printf("M=%d\n", M);
	for (i = 0; i < M; ++i) outs(ans[i]);
	return 0;
}


// ABC 155-C
// 2020.2.16 bal4u

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef long long ll;

#define gc() getchar_unlocked()
#define pc(c) putchar_unlocked(c)

int in() {   // 非負整数の入力
	int n = 0; int c;
	do c = gc();
	while (isspace(c));
	do n = 10 * n + (c & 0xf); while ((c = gc()) >= '0');
	return n;
}

ll ins() { // 文字列の入力　スペース以下の文字で入力終了
    ll n = 0;
	int c;
   	do c = gc();
	while (isspace(c));
    int w = 0;
	do n = (n << 5) + (c - 'a'+1), ++w;
    while ((c = gc()) > ' ');
    return n << 5*(10-w);
}

void outs(ll s) {
    int i;
    char a[20];
    i = 0; while (s) {
        if (s & 31) a[i++] = (s & 31) + 'a'-1;
        s >>= 5;
    }
    while (i--) pc(a[i]);
    pc('\n');
}

void Usort(ll *a, int n) {
	int i, k;
#define B 8
#define BMSK 255 // (1<<8)-1
	int t1[1 << B], t2[1 << B];

	ll *tmp = malloc(n * sizeof(ll));
	for (k = 0; k < 8; ++k) {  // for 64ビット
		memset(t1, 0, sizeof(t1)), memset(t2, 0, sizeof(t2));
		for (i = 0; i < n; ++i)	t1[(a[i] >> k*B) & BMSK]++;
		for (i = 0; i < BMSK; ++i) t1[i+1] += t1[i];
		i = n; while (i--) tmp[--t1[(a[i] >> k*B) & BMSK]] = a[i];
		k++;
		for (i = 0; i < n; ++i) t2[(tmp[i] >> k*B) & BMSK]++;
		for (i = 0; i < BMSK; ++i) t2[i+1] += t2[i];
		i = n; while (i--) a[--t2[(tmp[i] >> k*B) & BMSK]] = tmp[i];
	}
	free(tmp);
#undef B
}

#define MAX 200005
ll s[MAX]; int n[MAX];

int main()
{
	int i, j, k, N, ma;

    N = in();
	for (i = 0; i < N; ++i) s[i] = ins();
	Usort(s, N);

	j = 0, k = 1, ma = 0;
	for (i = 1; i < N; ++i) {
		if (s[i] == s[j]) ++k, n[i] = 0;
		else {
			n[j] = k;
			if (k > ma) ma = k;
			j = i, k = 1;
		}
	}
    n[j] = k;
    if (k > ma) ma = k;

	for (i = 0; i < N; ++i) {
		if (n[i] == ma) outs(s[i]);
	}
	return 0;
}


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct aa
{
    char* str;
    int num;
} ass;

int str_cmp(const void* a,const void* b){
    return strcmp((char*)a,(char*)b);
}

int main(void)
{
    int n=0,disit=0,max=0;
    char S[200000][11]={};
    ass map[200000];
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%s",S[i]);
    }
    qsort(S,n,sizeof(S[0]),str_cmp);

    map[0].str=S[0];
    for(int i=0;i<n;i++){
        if(strcmp(map[disit].str,S[i])==0){
            map[disit].num+=1;
        } else {
            disit+=1;
            map[disit].str=S[i];
            map[disit].num+=1;
        }
    }

    max=map[0].num;
    for(int i=0;i<=disit;i++){
        if(max<map[i].num){
            max=map[i].num;
        }
    }

    for(int i=0;i<=disit;i++){
        if(map[i].num==max){
            printf("%s\n",map[i].str);
        }
    }
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void){

    char a[1<<18][11];
    int table[1<<18];
    int N,i, max=-1;

    scanf("%d",&N);
    for(i=0;i<N;i++){
        scanf("%s",a[i]);
        table[i] = 1;
    }

    qsort(a,N,sizeof(a[0]),strcmp);

    for(i=1;i<N;i++){
        if(strcmp(a[i],a[i-1])==0){
            table[i] += table[i-1];
        }
        if(max<table[i]){
            max = table[i];
        }
    }

    for(i=0;i<N;i++){
        if(table[i]==max){
            printf("%s",a[i]);
        }
    }

    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void){

    char a[300000][11];
    int table[300000];
    int N,i, max=-1;

    scanf("%d",&N);
    for(i=0;i<N;i++){
        scanf("%s",a[i]);
        table[i] = 1;
    }

    qsort(a,N,sizeof(a[0]),strcmp);

    for(i=1;i<N;i++){
        if(strcmp(a[i],a[i-1])==0){
            table[i] += table[i-1];
        }
        if(max<table[i]){
            max = table[i];
        }
    }

    for(i=0;i<N;i++){
        if(table[i]==max){
            printf("%s",a[i]);
        }
    }

    return 0;
}


"use strict";

const main = arg => {
    arg = arg.trim().split("\n");
    const N = parseInt(arg[0]);
    const S = arg.slice(1, N + 1).sort();

    let list = [];
    let streak = 0;
    let max = 0;

    for(let i=0; i<S.length; i++) {
        if(S[i] === S[parseInt(i) + 1]) {
            streak++;
        } else {
            streak = 0;
        }

        if(streak > max) {
            max = streak;
            list = [S[i]];
        } else if(streak === max) {
            list.push(S[i]);
        }
    }

    console.log(list.join("\n"));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


'use strict'

function main(inp) {
  inp = inp.trim().split('\n')
  const N = inp.shift()
  inp = inp.sort()

  let ans = []
  let num = 0
  let count = 0
  for (let i = 0; i < inp.length; i++) {
    count++;
    if ((i + 1 === N) || inp[i] !== inp[i+1]) {
      if (count === num) {
        ans.push(inp[i])
      } else if (count > num) {
        num = count
        ans = [inp[i]]
      }
      count = 0
    }
  }

  console.log(ans.join('\n'))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


"use strict"
function Main(input) {
  input = input.trim().split('\n');
  const N = Number(input[0]);
  const S = input.slice(1, N+1);

  let arr = {};
  let max = 0;
  for(let i=0; i<N; i++){
    arr[S[i]] = arr[S[i]] ? arr[S[i]] + 1 : 1;
    if(arr[S[i]] > max) max = arr[S[i]];
  }

  let keys = Object.keys(arr);
  let ret = [];
  for(let i=0; i<N; i++){
    if(arr[keys[i]] === max) ret.push(keys[i]);
  }

  console.log(ret.sort().join('\n'));
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
  input=input.split("\n");
  if(input[input.length-1]===''){
    input.pop();
  }
  const N=input[0]-0;
  var string=[input[1]];
  var times=[1];
  for(var j=2;j<input.length;j++){
    for(var i=0;i<string.length;i++){
      if(string[i]===input[j]){
        times[i]++;
        break;
      }
      if(i===string.length-1){
        times.push(1);
        string.push(input[j]);
      }
    }
  }
  var max=Math.max(...times);
  var ret=[];
  for(var i=0;i<string.length;i++){
    if(times[i]===max){
      ret.push(string[i]);
    }
  }
  ret.sort();
  console.log(ret.join("\n"));

}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


"use strict"
const create = () => {
    const input = require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n");
    const res = {
        "list": input, "index": 0, "max": input.length,
        "hasNext": function() {return this.index < this.max},
        "next": function() { if (!this.hasNext()) {throw "ArrayIndexOutOfBoundsException";}else{return this.list[this.index++];}}
    };
    return res;
}
const o = create();
const next = () => o.next()
const nextInt = () => parseInt(o.next())
const nextStrArray = () => o.next().split(" ")
const nextIntArray = () => o.next().split(" ").map(el => parseInt(el))
const nextCharArray = () => o.next().split("")
const hasNext = () => o.hasNext()
const myout = (...x) => console.log(...x)
const Main = () => {
    const N = nextInt()
    let dict = {}
    let max = 0
    while(hasNext()){
        let str = next()
        if(!dict[str]) dict[str] = 1
        else dict[str]++
        max = Math.max(max, dict[str])
    }
    let ans = []
    for(let key of Object.keys(dict)){
        if(dict[key] === max){
            ans.push(key)
        }
    }
    ans.sort()
    myout(ans)
}
Main()


package main

import (
	"bufio"
	"os"
	"sort"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func scanInt() int {
	iv, _ := strconv.Atoi(scanString())
	return iv
}

func scanString() string {
	sc.Scan()
	return sc.Text()
}

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 100001), 100001*100)
}

func main() {
	n := scanInt()
	xm := make(map[string]int, n)
	for i := 0; i < n; i++ {
		s := scanString()
		xm[s]++
	}

	type poll struct {
		s string
		c int
	}
	ps := make([]poll, 0, len(xm))
	for s, c := range xm {
		ps = append(ps, poll{s, c})
	}
	sort.Slice(ps, func(i, j int) bool { return ps[i].c > ps[j].c })

	ans := make([]string, 0, len(xm))
	pmx := ps[0]
	ans = append(ans, pmx.s)
	for _, p := range ps[1:] {
		if p.c != pmx.c {
			break
		}
		ans = append(ans, p.s)
	}
	sort.Strings(ans)

	var wr = bufio.NewWriter(os.Stdout)
	for _, s := range ans {
		wr.WriteString(s + "\n")
	}
	wr.Flush()
}


package main

import (
	"bufio"
	"os"
	"sort"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func readInt() int {
	iv, _ := strconv.Atoi(readStr())
	return iv
}

func readStr() string {
	sc.Scan()
	return sc.Text()
}

type poll struct {
	s string
	c int
}
type polls []poll

func (p polls) Len() int           { return len(p) }
func (p polls) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p polls) Less(i, j int) bool { return p[i].c > p[j].c }

func main() {
	n := readInt()
	m := make(map[string]int, n)
	for i := 0; i < n; i++ {
		s := readStr()
		m[s]++
	}

	ps := polls(make([]poll, 0, len(m)))
	for s, c := range m {
		ps = append(ps, poll{s, c})
	}
	sort.Sort(ps)

	ans := make([]string, 0, len(m))
	pmx := ps[0]
	ans = append(ans, pmx.s)
	for _, p := range ps[1:] {
		if p.c != pmx.c {
			break
		}
		ans = append(ans, p.s)
	}
	sort.Strings(ans)

	var wr = bufio.NewWriter(os.Stdout)
	for _, s := range ans {
		wr.WriteString(s + "\n")
	}
	wr.Flush()
}


package main

import (
	"bufio"
	"os"
	"sort"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func scanInt() int {
	iv, _ := strconv.Atoi(scanString())
	return iv
}

func scanString() string {
	sc.Scan()
	return sc.Text()
}

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 100001), 100001*100)
}

func calcmax(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func main() {
	var N int
	var S string
	N = scanInt()
	max := 0
	m := map[string]int {}
	for i := 0; i < N; i++ {
	    S = scanString()
		m[S] = m[S] + 1
		max = calcmax(max, m[S])
	}
	l := []string {}
	for k, v := range m {
		if v == max {
			l = append(l, k)
		}
	}
	sort.Slice(l, func(i, j int) bool { return l[i] < l[j] })
	var wr = bufio.NewWriter(os.Stdout)
	for _, v := range l {
		wr.WriteString(v + "\n")
	}
	wr.Flush()
}


package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"sort"
	"strconv"
)

func main() {
	sc = initScanner(os.Stdin)
	n := scanInt(sc)
	ss := scanStringSlice(sc, n)
	solve(ss)
}

func solve(ss []string) {
	sort.Strings(ss)

	m := make(map[string]bool)
	var uniq []string
	for _, ele := range ss {
		if !m[ele] {
			m[ele] = true
			uniq = append(uniq, ele)
		}
	}

	var max, cnt int
	sn := make([]int, len(uniq))
	for i, v := range uniq {
		cnt = 0
		for _, s := range ss {
			if v == s {
				cnt++
			}
		}

		sn[i] = cnt

		if max < cnt {
			max = cnt
		}
	}

	for i := 0; i < len(uniq); i++ {
		if sn[i] == max {
			fmt.Println(uniq[i])
		}
	}
}

/*
arr := [string]{"a", "b", "c", "a"}
uniq := [] string{}

for _, ele := range arr {
    if !m[ele] {
        m[ele] = true
        uniq = append(uniq, ele)
    }
}
*/

// --------------- BASE DEFINITIONS ---------------

const (
	initialBufSize = 100000
	maxBufSize     = 1000000
)

var sc *bufio.Scanner

func initScanner(r io.Reader) *bufio.Scanner {
	buf := make([]byte, initialBufSize)

	sc := bufio.NewScanner(r)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords)
	return sc
}

func scanInt(sc *bufio.Scanner) int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}

func scanIntSlice(sc *bufio.Scanner, n int) []int {
	is := make([]int, n)
	for i := 0; i < n; i++ {
		is[i] = scanInt(sc)
	}

	return is
}

func scanFloat64(sc *bufio.Scanner) float64 {
	sc.Scan()
	f, _ := strconv.ParseFloat(sc.Text(), 64)
	return f
}

func scanFloat64Slice(sc *bufio.Scanner, n int) []float64 {
	fs := make([]float64, n)
	for i := 0; i < n; i++ {
		fs[i] = scanFloat64(sc)
	}

	return fs
}

func scanString(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

func scanStringSlice(sc *bufio.Scanner, n int) []string {
	ss := make([]string, n)
	for i := 0; i < n; i++ {
		sc.Scan()
		ss[i] = sc.Text()
	}

	return ss
}

func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}


package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)

	s := map[string]int{}
	max := 1
	for i := 0; i < n; i++ {
		var tmp string
		fmt.Scan(&tmp)
		_, exists := s[tmp]
		if !exists {
			s[tmp] = 1
		} else {
			s[tmp]++
			if max < s[tmp] {
				max = s[tmp]
			}
		}
	}

	for k, v := range s {
		if v == max {
			fmt.Println(k)
		}
	}
}


package main

import (
    "fmt"
    "os"
    "bufio"
    "sort"
    "strconv"
    "math"
)

var (
    read = bufio.NewReader(os.Stdin)
    write = bufio.NewWriter(os.Stdout)
    sc = bufio.NewScanner(os.Stdin)
)

func main() {
    defer write.Flush()

    var n int
    fmt.Fscan(read, &n)

    s := make(map[string]int)

    sc.Split(bufio.ScanWords)
    max := 0
    for i := 0; i < n; i++ {
        str := nextStr()
        _, ok := s[str]
        if ok {
            s[str]++
        } else {
            s[str] = 1
        }
        if max < s[str] {
            max = s[str]
        }
    }

    var a []string
    for key := range s {
        a = append(a, key)
    }

    sort.Strings(a)

    for i := 0; i < len(a); i++ {
        if s[a[i]] == max {
            fmt.Printf("%s\n", a[i])
        }
    }

}

//===========================
//
// Library
//
//===========================

//====================
//  round(12.54, 0) -> 13.0
//  round(12.54, -1) -> 12.5
//====================

func round(num float64, digit uint) float64 {
    d := float64(digit)
    return float64(int(num * math.Pow(10, d) + 0.5)) / math.Pow(10, d)
}

func max(a, b int) int {
    return int(math.Max(float64(a), float64(b)));
}

func min(a, b int) int {
    return int(math.Min(float64(a), float64(b)));
}

func gcd(x, y int) int {
    if y == 0 {
        return x
    }

    return gcd(y, x%y)
}

//====================
//  var q Queue
//  q.Enqueue(n)
//  n := q.Dequeue()
//====================
type Queue struct {
    data []int
}

func (q *Queue) Enqueue(n int) {
    q.data = append(q.data, n)
}

func (q *Queue) Dequeue() int {
    tmp := q.data[0]
    q.data = q.data[1:]
    return tmp
}

// 数値を桁区切りのスライスにする
func digit(n int, list []int) []int {
   if n > 0 {
       return digit(n/10, append(list, n%10))
   }
   return list
}

func sortIntsRev(list []int) {
    sort.Sort(sort.Reverse(sort.IntSlice(list)))
}

func strReverse(s string) string {
    runes := []rune(s)
    for i := 0; i < len(s)/2; i++ {
        runes[i], runes[len(s)-1-i] = runes[len(s)-1-i], runes[i]
    }
    return string(runes)
}

func nextInt() int {
    sc.Scan()
    i, _ := strconv.Atoi(sc.Text())
    return i
}

func nextStr() string {
    sc.Scan()
    return sc.Text()
}


_,*A=*$<
A=A.tally
k=A.map{_2}.max
puts A.map{_2<k ?"":_1}.sort


input = readlines()

n = input.shift.chomp.to_i

list = {}
input.each do |l|
  s = l.chomp
  list[s] = 0 if list[s].nil?
  list[s] += 1
end

max = list.values.max

keys = []
list.each do |k, v|
  keys.push(k) if v == max
end

puts keys.sort.join("\n")


counts = {}
counts.default = 0
gets.to_i.times{|i|
    counts[gets.chomp] += 1
}
m = counts.values.max

ans = []
counts.each{|key, val|
    ans.push(key) if val == m
}

ans.sort.each{|it| puts it}


n=gets.to_i
s=Array.new(n,"")
n.times do |i|
    s[i]=gets.chomp
end

count=1
curr=Array.new(n,0)
s=s.sort
i=0
while i<n
    curr[i]=s.count(s[i])
    i+=curr[i]
end

n.times do |i|
    if curr[i]==curr.max
        puts s[i]
    end
end


n=gets.to_i
s=Array.new(n,"")
n.times do |i|
    s[i]=gets.chomp
end

count=1
curr=Array.new(n,0)
s=s.sort
(n-1).times do |i|
    if s[i+1]==s[i]
        count+=1
    else
        curr[i]=count
        count=1
    end
end
curr[n-1]=count

n.times do |i|
    if curr[i]==curr.max
        puts s[i]
    end
end


N = gets.to_i
h = Hash.new(0)

(0..N-1).each { |i|
  s = gets.chomp
  h[s.to_sym] += 1
}

h.sort.each { |k, v| puts k if v == h.values.max }


#[doc = " https://github.com/hatoo/competitive-rust-snippets"]
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[macro_export]
macro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }
#[macro_export]
macro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }
#[macro_export]
macro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }
#[macro_export]
macro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }
#[macro_export]
macro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }
#[doc = " main"]
#[allow(unused_imports)]
use std::io::{stdin, stdout, BufWriter, Write};
#[macro_export]
macro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }
#[macro_export]
macro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }
#[macro_export]
macro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( "Parse error" ) } ; }
use std::io;
use std::io::BufRead;
use std::str;
pub struct Parser<R> {
    reader: R,
    buf: Vec<u8>,
    pos: usize,
}
impl Parser<io::Empty> {
    pub fn from_str(s: &str) -> Parser<io::Empty> {
        Parser {
            reader: io::empty(),
            buf: s.as_bytes().to_vec(),
            pos: 0,
        }
    }
}
impl<R: BufRead> Parser<R> {
    pub fn new(reader: R) -> Parser<R> {
        Parser {
            reader: reader,
            buf: vec![],
            pos: 0,
        }
    }
    pub fn update_buf(&mut self) {
        self.buf.clear();
        self.pos = 0;
        loop {
            let (len, complete) = {
                let buf2 = self.reader.fill_buf().unwrap();
                self.buf.extend_from_slice(buf2);
                let len = buf2.len();
                if len == 0 {
                    break;
                }
                (len, buf2[len - 1] <= 0x20)
            };
            self.reader.consume(len);
            if complete {
                break;
            }
        }
    }
    pub fn next<T: str::FromStr>(&mut self) -> Result<T, T::Err> {
        loop {
            let mut begin = self.pos;
            while begin < self.buf.len() && (self.buf[begin] <= 0x20) {
                begin += 1;
            }
            let mut end = begin;
            while end < self.buf.len() && (self.buf[end] > 0x20) {
                end += 1;
            }
            if begin != self.buf.len() {
                self.pos = end;
                return str::from_utf8(&self.buf[begin..end]).unwrap().parse::<T>();
            } else {
                self.update_buf();
            }
        }
    }
}
#[allow(unused_macros)]
macro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , " = {:?}, " ) ,* ) , $ ( $ a ) ,* ) ; } }
#[doc = " https://github.com/hatoo/competitive-rust-snippets"]
const BIG_STACK_SIZE: bool = true;
#[allow(dead_code)]
fn main() {
    use std::thread;
    if BIG_STACK_SIZE {
        thread::Builder::new()
            .stack_size(32 * 1024 * 1024)
            .name("solve".into())
            .spawn(solve)
            .unwrap()
            .join()
            .unwrap();
    } else {
        solve();
    }
}
fn solve() {
    let out = stdout();
    let mut out = BufWriter::new(out.lock());
    input!{
        n: usize,
        s:[String;n]
    }
    let mut s = s;
    s.sort();
    let rls = run_length_compression(&s);
    let m = rls.len();
    let mut maxfreq = 0;
    for i in 0..m {
        let n = rls[i].1;
        chmax!(maxfreq,n);
    }
    for i in 0..m {
        let st = rls[i].0.clone();
        let n = rls[i].1;
        if n == maxfreq {
            writeln!(out,"{}",st);
        }
    }
}
#[doc = "O(N)"]
fn run_length_compression<T: Eq + Clone>(xs: &[T]) -> Vec<(T, usize)> {
    if xs.is_empty() {
        return vec![];
    }
    let mut cur = &xs[0];
    let mut rep = 1;
    let mut res = vec![];
    for i in 1..xs.len() {
        if &xs[i] == cur {
            rep += 1;
        } else {
            res.push((cur.clone(), rep));
            cur = &xs[i];
            rep = 1
        }
    }
    res.push((cur.clone(), rep));
    res
}


#[test]
fn test_solve() {
    assert_eq!(solve("7\nbeat\nvet\nbeet\nbed\nvet\nbet\nbeet\n"), "beet\nvet\n");
    assert_eq!(solve("8\nbuffalo\nbuffalo\nbuffalo\nbuffalo\nbuffalo\nbuffalo\nbuffalo\nbuffalo\n"), "buffalo\n");
    assert_eq!(solve("7\nbass\nbass\nkick\nkick\nbass\nkick\nkick\n"), "kick\n");
    assert_eq!(solve("4\nushi\ntapu\nnichia\nkun\n"), "kun\nnichia\ntapu\nushi\n");
}

fn solve(src: &str) -> String {
    let mut sc = Scanner::from_str(src);

    let n: usize = sc.read();
    let mut s: Vec<Vec<char>> = (0..n).map(|_| sc.chars()).collect();

    s.sort();

    let mut mct = 0;
    let mut cnt = 1;
    for i in 0..n-1 {
        if s[i] == s[i+1] {
            cnt += 1;
        } else {
            cnt = 1;
        }
        if cnt > mct {
            mct = cnt;
        }
    }

    let mut ret = String::new();
    use std::fmt::Write;

    cnt = 1;
    if cnt == mct {
        for &c in &s[0] {
            write!(&mut ret, "{}", c).unwrap();
        }
        writeln!(&mut ret, "").unwrap();
    }
    for i in 0..n-1 {
        if s[i] == s[i+1] {
            cnt += 1;
        } else {
            cnt = 1;
        }
        if cnt == mct {
            for &c in &s[i+1] {
                write!(&mut ret, "{}", c).unwrap();
            }
            writeln!(&mut ret, "").unwrap();
        }
    }

    ret
}

fn main() {
    let mut buf = String::new();
    use std::io;
    use std::io::{Read, Write};
    io::stdin().read_to_string(&mut buf).unwrap();
    io::stdout().write_all(solve(&buf).as_bytes()).unwrap();
}

struct Scanner<'a>(std::str::SplitWhitespace<'a>);
impl<'a> Scanner<'a> {
    fn from_str(src: &str) -> Scanner {
        Scanner(src.split_whitespace())
    }
    fn get(&mut self) -> &str {
        self.0.next().unwrap()
    }
    fn read<T: std::str::FromStr>(&mut self) -> T {
        self.get().parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.get().chars().collect()
    }
}


use std::io::Read;
use std::collections::HashMap;
use std::cmp::max;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

    println!("{}", answer);
}

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let n: usize = iterator.next().unwrap().parse().unwrap();

    let mut map: HashMap<&str, usize> = HashMap::with_capacity(n);
    for _i in 0..n {
        *map.entry(iterator.next().unwrap()).or_insert(0) += 1;
    }

    let mut max_count: usize = 0;
    for (_, &v) in &map {
        max_count = max(max_count, v);
    }

    let filtered = map.into_iter()
        .filter(|&(_, v)| v == max_count)
        .collect::<HashMap<&str, usize>>();

    let mut keys = Vec::with_capacity(filtered.len());
    for &key in filtered.keys() {
        keys.push(key)
    }

    keys.sort();

    return keys.join("\n");
}

#[test]
fn test() {
    assert_eq!(
        solve(
            r"7
beat
vet
beet
bed
vet
bet
beet"
        ),
        "beet
vet"
    );
//    assert_eq!(
//        solve(
//            r""
//        ),
//        ""
//    );
//    assert_eq!(
//        solve(
//            r""
//        ),
//        ""
//    );
}


use std::collections::BTreeMap;
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("filed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n:usize = read();
    let mut map = BTreeMap::new();
    for _ in 0..n {
        let x:String = read();
        *map.entry(x).or_insert(0) += 1;
    }
    let mut v = Vec::new();
    for (key, value) in map {
        v.push((value as usize, key));
    }
    v.sort();
    let c:usize = v.last().unwrap().0;
    let mut v:Vec<(usize, String)> = v.into_iter().filter(|&&x| x.0 == c).collect();
    for (num, s) in v {
        println!("{}", s);
    }
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

use std::collections::HashMap;

fn main(){
    input!{
        n: u64,
        s:[String;n]
    }
    s.sort();
    let mut map = HashMap::new();
    let mut flug :bool = false;
    for i in s.iter(){
        let count = map.entry(i).or_insert(0);
        *count += 1;
    }
    let mut max:u64 = 0;
    map.sort_by(|a, b| a.0.cmp(&b.0));
    for i in 0..sc.len() {
        if max < sc[i].1 {max = sc[i].1;}
    }
    for i in 0..sc.len() {
        if max == sc[i].1 as u64 {
            println!("{}", sc[i].0);
        }
    }
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

use std::iter::FromIterator;

fn main(){
    input!{
        n: u64,
        s:[String;n]
    }
    let mut sc:Vec<(String, u64)> = Vec::new();
    let mut flug :bool = false;
    for i in s.iter(){
        for j in 0..sc.len(){
            if i == &sc[j].0 {
                sc[j].1 += 1;
                flug = true;
                break;
            }
        }
        if ! flug {
            sc.push((i.to_string(), 1));
        }
        flug = false;
    }
    let mut max:u64 = 0;
    sc.sort_by(|a, b| a.0.cmp(&b.0));
    for i in 0..sc.len() {
        if max < sc[i].1 {max = sc[i].1;}
    }
    for i in 0..sc.len() {
        if max == sc[i].1 as u64 {
            println!("{}", sc[i].0);
        }
    }
}


import Foundation

func main(){
    let counter = Int(readLine()!)!
    var aryStr = [String]()
    var aryInts = [Int]()

    for _ in 1...counter {
        aryStr.append(readLine()!)
        aryInts.append(1)
    }
    let ziped = zip(aryStr,aryInts)
    let dicUniq = Dictionary(ziped, uniquingKeysWith: +)
    let max = dicUniq.values.max()
    var ans = [String]()

    for dic in dicUniq {
        if dic.value == max {
            ans.append(dic.key)
        }
    }
    ans.sort() { $0 < $1 }
    for a in ans {
        print(a)
    }
}

main()


import Foundation

let n = Int(readLine()!)!

var dic: [String] = []
for i in 0 ..< n {
    dic.append(readLine()!)
}

var w: [String: Int] = [:]

for i in 0 ..< n {
    if w[dic[i]] == nil {
        w[dic[i]] = 1
    } else {
        w[dic[i]]! += 1
    }
}

let sorted = w.sorted(by: <).sorted(){ $0.1 > $1.1 }
let max = sorted.first!.value
sorted.forEach {
    if $0.1 < max {
        return
    }
    print($0.0)
}


import Foundation

func main(){
    let counter = Int(readLine()!)!
    var aryStr = [String]()
    var aryInts = [Int]()

    for _ in 1...counter {
        aryStr.append(readLine()!)
        aryInts.append(1)
    }
    let ziped = zip(aryStr,aryInts)
    let dicUniq = Dictionary(ziped, uniquingKeysWith: +)
    let max = dicUniq.values.max()
    var ans = [String]()

    for dic in dicUniq {
        print(dic)
        if dic.value == max {
            ans.append(dic.key)
        }
    }
    ans.sort() { $0 < $1 }
    for a in ans {
        print(a)
    }
}

main()


import Foundation

let votesCount = Int(readLine()!)!
var ary = [String]()

var strCounter = [String:Int]()

for _ in 1...votesCount {
    ary.append(readLine()!)
}
for a in ary{
    strCounter[a, default:0] += 1
}

let _ = strCounter.sorted{$0.value > $1.value}
var max = 0
for str in strCounter{
    max = str.value
    if max >= str.value {
        print(str.key)
        break
    }
}


import Foundation

let N = Int(readLine()!)!
var array = [String]()
var dictionary = [String: Int]()
var max = 0
for i in 0..<N {
  var key = readLine()!
  let value = dictionary[key] ?? 0
  dictionary[key] = value + 1
  if max < value + 1 {
    max = value + 1
  }
}
let answer = dictionary.filter { $0.1 == max }
array = answer.map { $0.0 }
array.forEach { print($0) }


const main = (input: string) => {
  const lines = input.trim().split("\n")
  const countMap = new Map()
  let maxCount = 0

  lines.slice(1).forEach(S => {
    if (!countMap.has(S)) {
      countMap.set(S, 1);
    } else {
      countMap.set(S, countMap.get(S) + 1)
    }
    maxCount = Math.max(countMap.get(S), maxCount)
  })

  const answer = Array.from(countMap).filter(entry => entry[1] === maxCount).map(entry => entry[0]).sort()

  console.log(answer.join("\n"))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


const main = (input) => {
  const lines = input.trim().split("\n");
  const N = parseInt(lines[0]);
  const countMap = new Map();

  let maxCount = 0;
  lines.slice(1).forEach(S => {
    if (!countMap.has(S)) {
      countMap.set(S, 1);
    } else {
      countMap.set(S, countMap.get(S) + 1)
    }
    maxCount = Math.max(countMap.get(S), maxCount);
  });

  const answer = Array.from(countMap).filter(entry => entry[1] === maxCount).map(entry => entry[0]).sort();
  console.log(answer.join('\n'));
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


process.stdin.resume();
process.stdin.setEncoding('utf8');

// 標準入力取込
var g_input = '';
process.stdin.on('data', function(chunk) {
    g_input += chunk;
});
process.stdin.on('end', function() {
    main(g_input.split(/\r?\n/));
});

// 解答
function main(inputs:Array<string>) : void {

    // 枚数
    let count: number = Number(inputs[0].split(' ')[0]);
    let strMap: {[key: string]: number} = {};

    // 文字列の格納&回数計算
    for (let i = 1; i <= count; i++) {

        if (inputs[i] in strMap) {

            strMap[inputs[i]] = strMap[inputs[i]] + 1;
        } else {
            strMap[inputs[i]] = 0;
        }
    }

    let max = 0;
    let strList: string[] = [];

    // 回数最大の文字列抽出
    for (let str in strMap) {

        if (strMap[str] > max) {

            strList = new Array();
            max = strMap[str];
        }

        if (strMap[str] == max) {

            strList.push(str);
        }
    }

    return console.log(strList.sort().join('\n'));
}


function main(input: string) {
	const i = input.split("\n");
	const n = parseInt(i[0], 10);
	const s = i.splice(1, n);
	//console.log(s);

	const pollDictionary: { [key: string]: number } = {};
	let maxNum = 0;
	let maxNumPoll = "";

	for (let i = 0; i < s.length; i++) {
		const pollName = s[ i ];
		let pollNameCount = pollDictionary[ pollName ] == null ? 1 : pollDictionary[ pollName ] + 1;
		pollDictionary[ pollName ] = pollNameCount;

		if ( maxNum > pollNameCount ) {
			continue;
		}

		maxNum = pollNameCount;
		maxNumPoll = pollName;
	}

	//console.log( maxNum );
	console.log(maxNumPoll);

}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));

//const input:string =　"7¥nbeat¥nvet¥nbeet¥nbed¥nvet¥nbet¥nbeet";
//main(input);


const main = (input: string) => {
  const S = input.trim().slice(2).split("\n")
  const countMap = new Map()
  let maxCount = 0

  S.forEach(s => {
    if (!countMap.has(s)) {
      countMap.set(s, 1);
    } else {
      countMap.set(s, countMap.get(s) + 1)
    }
    maxCount = Math.max(countMap.get(s), maxCount)
  })

  const answer = Array.from(countMap).filter(entry => entry[1] === maxCount).map(entry => entry[0]).sort()

  console.log(answer.join("\n"))
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


const main = (input) => {
  const lines = input.trim().split("\n");
  const N = parseInt(lines[0]);
  const countMap = new Map();

  let maxCount = 0;
  lines.slice(1).forEach(S => {
    if (!countMap.has(S)) {
      countMap.set(S, 1);
    } else {
      countMap.set(S, countMap.get(S) + 1)
    }
    maxCount = Math.max(countMap.get(S), maxCount);
  });

  const answer = Array.from(countMap).filter(entry => entry[1] === maxCount).map(entry => entry[0]).sort();
  console.log(answer.join('\n'));


# compiled by pythran
"""
#pythran export main2()
import numpy as np
i4 = np.int32
i8 = np.int64

INF = 1000000000

def solve(a, ch, cw):
    sh1 = np.empty(1000000, i4)
    sw1 = np.empty(1000000, i4)
    p1 = 0
    sh2 = np.empty(1000000, i4)
    sw2 = np.empty(1000000, i4)
    p2 = 0

    dis = 0
    a[ch, cw] = dis
    sh1[p1] = ch
    sw1[p1] = cw
    p1 += 1

    while True:
        while p1 > 0:
            p1 -= 1
            h = sh1[p1]
            w = sw1[p1]
            for i in range(-2, 3):
                for j in range(-2, 3):
                    if ((i == 1 or i == -1) and j == 0) or (i == 0 and (j == 1 or j == -1)):
                        if a[h + i, w + j] > dis:
                            a[h + i, w + j] = dis
                            sh1[p1] = h + i
                            sw1[p1] = w + j
                            p1 += 1
                    else:
                        if a[h + i, w + j] > dis + 1:
                            a[h + i, w + j] = dis + 1
                            sh2[p2] = h + i
                            sw2[p2] = w + j
                            p2 += 1

        dis += 1
        for i in range(p2):
            if a[sh2[i], sw2[i]] == dis:
                sh1[p1] = sh2[i]
                sw1[p1] = sw2[i]
                p1 += 1
        p2 = 0

        if p1 == 0:
            break

    return a

def main(in_file):
    stdin = open(in_file)
    H, W = [int(x) for x in stdin.readline().split()]
    ch, cw = [int(x) for x in stdin.readline().split()]
    dh, dw = [int(x) for x in stdin.readline().split()]
    a = np.empty((H + 4, W + 4), i8)
    for i in range(H + 4):
        for j in range(W + 4):
            a[i, j] = -1
    t = stdin.read()
    m = 0
    for i in range(2, H + 2):
        for j in range(2, W + 3):
            if ord(t[m]) == 46:
                a[i, j] = INF
            m += 1
    solve(a, ch + 1, cw + 1)
    ans = a[dh + 1, dw + 1]
    if ans == INF:
        print(-1)
    else:
        print(ans)

def main2():
    main('/dev/stdin')
"""
import os, sys
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
if len(sys.argv) == 1:
    import subprocess
    if p == "":
        pymain = "./" + pymain
    subprocess.call(pymain)
else:
    import gzip, base64, stat
    gz = b'H4sIALwCQl8C/+19C3gTVdrwpNeA0BRELPegBVuB0nBtETGlDUwghUoL4gWHkKY02ia1mXBxUWHbIjEEuq7rsvvpyrp+u3hBEV0FRGi5tIg3RBQUXdh1lZTIxRsWBfK/7zlnkplpAi263/f8/2+UnjnvnPOe936uM/OAyTIpTqPhpF8cN4HD3Nq+RpI3Mvi6N8JFAJbDdYK/A7j+XBLkE2TljJxRkbYy1FKqZeXiWb2cOJrPiTMq0r6snJRqZGkiJ/8ZFemm1Zwi5Th9uB7SmvEYhWY8NleRNjCkp5OU9eJYvcDjFBp4fK4i5eI4RSrxl8D+lTB4CeNLSgtYuQJZefwVfS6W4rX2QYbvQaMiPcDKHVDVuxnqJXHt/6WydAZrL5ZcDsVzilTSw/AKx7wxo4ZXlA6rcDg9i4YtyhkzbMyoLLcrawShKZWVnTxtZljfcTKaezAY3t9afvKLcS/m/H7iupdu73Hr7689cU/593hvDKuTDP9qV6fO7ZLZKQ5rLu3CafDeOPh3E/x75jfjdzxme31352X1wkufjPxg6FfCnSm1/b44ULy2ZkWdrefdv3t52J/6Vm3qsaZL/iLz3a9kmj6wxJJLCjTWPQrcrIkOX8xFh69JiA5/Jy46fFSMdqfHaHdIDLgzKTp8Rwx4jxjtvhyj/ITE6PArYpSfHQN/cwz6b4hRPj1G+XdjyF+IgefTGHr5VYzyfAx4eQx6no9BT2kMvWtj4H84Bjw3Pjr8nzHwl8XAc00M+Csx+KqMUf7ZGO2mxYDbY9A/PYZeMmO0ezYG/qwY5V+PYbefxWjXHQPP32LQH4ih9xEx2j0Vw1/0MeC/jdHu0hh0poZ7MOXv5hh4MOAO5K7i9rC4L9Wt4yg8wOCzJX7jKNzI+kGpP7mP4Sli8DQGF0EO3bA8wyP1I9MY/fW9jAp6bmdyK+qthI9l+jL2VcKXJdJ2y1m7S6XyjH7+MSUcO8tuXG+Oe5LRzwgqZXrc10eJfwCDz1W1y0E/6BZLbUOGYN83hhOE+ZUup+AWrdWiIHDCbdOKxRyHyy3Ms7rto8xOh1hgMC0AeMmsYtEwGqAOG5Sutlsr53nKzDYAGmzl1mpBrLY6RLfZZjIhzkWLhCp7tdvltFY4xMXCgmyC2TWyyiOabATbNEO2INgWLbLOcywwjIBrt0OwVVjdbkFcXGUXHM4ylwkrTS0WR9sQBKgNI4VCYaGj1O6E+w6R0AVYcwHqcLrt1aK5wmSaUewqYYzkUnKBnaiEjrZV2K3VJrgzQjADy/BPtIp2qFtaUYS4i0UkTCyvdi0UKuzO+WK5YK+udlUXTUUenNZKDlmwCtaKCpcNagr2RTZ7lehwOUllwxhBcFFZSfRFI2MGwEZSSllpc4lQki2YiscIRVOLRwoVlJsx2EiFnekDAGOJAA0GQ26ktsM5n+GI0lSxFdvLNyDLIwnL06vszkpXqZ1JOoxxRFjRgDA2KsPIMoezVChzVLtFwVVmAsFUVqqIay+qEaBFm8sJ5Tw20VRpo/IfJcnf5cEWhGqrc75dKKsUoal7VeZaMIJIptRKlFdiBgOQK+QyiBpbbQe1LbCbKsMKpdTMs5YKNqtbxIacCytngOxynS56T4zmRfnMi8wo+mqPU3RU2qkxMVMNU8q4uCx1jJWpA8iRq6Sk5PItRnLECJGjFpZbxTZ22F4ys0HV1faqCqsNJFuJFF4eInR8axWYcKmJIQFdXK7sxhDZQQRSi464OFEtNYLccEhwzQfEsogwrY1ymbMCOcw6aOyTkTdaTl6MkCrTQpsWwLBmTL0M2ZkYY2XVdmXcukw92MCERLtpRiV1lVE2cNifoFW32zHfCZwVj6Kx3DW6rMLjLqcODtFZ5XHQq1XSDg2u5tugEcwZOGGmcyGqdYbd7am0400bLVbmArPhykR7BURXbA6is1BmdVRwQJ7oquDK7K4yrmy+XXQjBKK/FOtF+yKHyJW57fa7uQVuZxUwI5ZxlfZKW9VirsxW4XLbuUrSI3AgW2sp3qp0LbBz82yVVYAEaWD9baXV4cRCdm5yfr4wMiubm2wxT8yfPRuuR2WNUGYNBkU2l4OrvIlmwZA1UllNUY5eCyOyDJHLEVmjyUw1Hv5LgH9xXGL4CmGJXBLk8DqZ/I2D/5I5LYHREnEM3onUQjj9R/8ihs4MH0fuJ5Ja8bI24wkMx1Ua7p9JkfFf0eDFV3BQ+/fJ0vw9iYy98H4V/mv9PSDtxD2RTGFWktdyz7O894HMOJyBv87y779wdyKuwLzJ8veQ8gnchywvZj6sRRo/D7cXx11IiowPH/nNo0m4ovIVK+/p7eiEsjvHygeeoOMxXMsYKRtmnZbBR8lXf9i4LpGtB4TnbTL4TTL4Hhl8jHz8LoOPleN/PALPkcGLZPBc+bxQBp8gHyc+GYHLR5Bpayk8WTYmJuNvGTxOBs+QweNl8GwZPEEGz5HB5etmRhlcvm7Ey+DJcn5lcK18fi+Dd5LB58rgneXykcFvkMGrZPArZPBFMngX+bxHBu8qg6+QwVNk8HoZXCdfp5HBU2XwtTJ4Nxl8nQwun0dtkMGvlME3yeA9ZPAGGfwquX3K4ONl8H0yeE8Z/JAMfrUMflQGT5PbuQzeS+5fMnhvGbxVBu8jt+c/R+B95esZMng/+XxUBu8vt38ZfIDc/mVw+Tw2QwYfKLd/Gfwauf3L4NfK7V8GT5fbvww+SG7/Mvhguf3L4NfJ7V8Gz5DbvwyeKbd/Gfx6uf3L4EPk9i+DD5XbvwyeJ7d/GXyY3P5l8Cy5/cvgw+X2L4Nny+1fBjfI7V8GHyG3fxn8Rrn9y+Cj5fYvg0+U66vmSy3vSxz0oJ7j6xrEuNA+vmaXdmf4fmj0NXArNCgd/uoGGOEK8+V4q+VoCH6DemMeQ2/LPpLvjnkMuS0NJN8Z8xhqWzaQfBzmMcS2rCX5H5ZDHkNrSz3Jf415DKktS0n+OOaR7JYqkv8X5jGEtswl+Y8xj6GzpYjk92MeQ2aLkeT3Yh5DYks2ye/APIbCFj3Jb8E8hsCWVJLfiHkMfS0cyT+DeQx5LacvYP5JzKcS/kn+j5jvRvgn+Ycx353wT/IPYf5Kwj/J/xrzPQj/JH8v5q8i/JN8NeZ7Ev5J/i7MX034J/l5mE8j/JP8bZjvRfgn+RmY7034J/kpmO9D+Cf5iZjvS/gn+XGY70f4J/kRmO9P+Cf56zE/gPB/HvPXYF5P+Cf53pgfSPgn+e6Yv4bwT/KdMX8t4Z/k4zCfTvgn+R/qID+I8E/yX2N+MOGf5I9j/jrCP8n/C/MZhH+S/xjzmYR/kt+P+esJ/yS/F/NDCP8kvwPzQwn/JL8F88MI/yS/EfNZhH+Sfwbzwwn/54j+MZ9N+Cf5P2LeQPgn+YcxP4LwT/IPYX4k4Z/kf435UYR/kr8X86MJ/yRfjfkxhH+SvwvzYwn/kC/a3u0vc7nAB6Ca7biWtg2zW46CdwfuAXJn7yzL0g2oJa6rG1AAseSE2fvenbz3X3zNv08XlZibG+qrjRzf3KgnSfPafuDTV/Wv0XPfkvLfKBAYuU0BQM3fiH/FKzeRiAFhotN2BISOltXvJLUidbaR8stOkqTxQjzvPc03Bm7iNU38exfEbmEMyQyDuv7SGzcDv5zn6pm89/PA/SCApsS/AUQzh5ZUlw+uUtHL7f3jDTIe8mYVF/Hez7Y9hex6jwSGwiAUU7zL+/qm83WHxQy+Jl8f8gzkfTfw/vxUPrdZTAyMBGFjwSGYNieQPs7QgMHx9rw7d5q9TRet/d2PtPaJHyO1Ld7vA5+CjuQEczPzbsmblTczr6SYX/ZlDoRJszfE+7emp0FE3fbOQiMXuBd0zzfXpm9iEbmpNr0B0+1og9tw/B5oBqwo1Aze28jXNKbyXi3fbCTDzCZjKtQ26jFAQ0q60mAcMLI5RH8P8N7a9D1417syfR9H2zrE2rL4niKUWLxPpeMKfWHdv8Ukc01Bul5j9iVjzdNMn4l8DTQio2kko2kC793J1zQATfHbCBHeI1swOgfmEdHkM8ryCWW897H0VtqOJ61lJUQBw2EZTFe7GEBm39D0goc83Pa0cGNN50hjutrHCJKdvN+jyVt6YSavM32H0lwLjQQMY7BuMilnGIzqf47c4OtO6Gr1BJDD+zxc4NAPqLx4vsYEeh3M++7jeL+JKbYvuXcq0ANTkNRaNukADrSMEzIMRuSHGEckrTvh6RUcD+y0vSEOgqa0IU9/0lRdCJr54CxtZj2mPqnkYV3twXTss2/ggIVBxBaO4sSH920l+oHKutqZcGPbC2Dvm7EXNuwPrEFaa1rh1hNKu1n9I9VRJu/dTXVkAgZM1HBMaDgmph6TZDgnwMwD338fCqEH+KlVoh1sklkmEkwt6jmagpfoqZf0UnjJu63US5ohtXhfJuZHrCvkuc7sG59u9heks6JPkSLHAo+1UrmnSXL3L0mfy/tfJgQE3hmPEKpv3i+mzw0MHU3poYoGAb5wLQowPw1kNsTis2m3Z4TFsfQHZkVPXYt+2Mx7+6brbmnQdUPPoVptNqYxTyKDanPmlxbvZ3zjjxDnDkGcu9HiXZKeoasLXsvsdQpxnmOBq1qJxMy+m5h+QYKF3rGF3oVasz/hH2bv5FQsv6o3lDf7J4MmCtK15ppmLSLMMTd+GW+u2aUJDqnnvXOA/N1a3rvH4oO2eG8G76sAKQEMioTMNec0ulXvE+kjGGzoVhP1CZ8lHew7k/cBav6GDM/LeAW1OWwsm8/cbfaeMjeG4sEiLd7WzYRPXUHjNP/QnHC0GGDOfduim9xi0bRadBNbCsF4u0/xjz9BpkbZ1CyC8SbDman+hAuI1zjV2/cCYOR9d6RniykQA3nvP3jv8UANKhIoNxJuwEK0aAmvnwE1I18gHLPXpZ3qH3qSENxyZQjLD00HV0kLif1JoqutJ+Z2B5gA6LauK9DcYkBN++ZA7PJoLbnfeAaRWnWHPZbgjLJ6FMjsM2hD8XT4u1Nrzv2HeC1YA3riKer0AbnTvxW4DioEdxM8gDhMbOoZ6qRaTAk9dVWEykjjGVLj04MzSc+F5Q9918H2//Zd1Pbrv6Ptr/hOFYuYQMCvidNdo3C6276jTjeD1CpIn9vWjR7MVbvR5waVG+EIMIYb5X7P3GgOlontQ2Ad+iiOtEkyNT53p+7BZ/XMk+YyT3rzWxp7fFgbAjZxp+Xfotgt6XqL12Dx3kN8ivfmUZ8aTAwCi/t5cAgLWH9NgxabjzjWCKlLvgz/Opt3Ef/S/4z+te+b2P6FxFL/sngvoH9d+53MvwrrQmgUehHiSSgw+xuMpSN5790y/0r5+fyr9esO2nfz11Hte8PX1L7Xfd0x/1rU0fYnR28/m7Wf8XVH/OuHr6h/ff1VTP+6bozav+qyVP6l7RfTvz76hvnX+b6X8q+iS/rXzH4q/7r7q7B/FYX9a/BX1L+KLuZfRf8h//rDhIv4V9HP6F9VpzvQf+38Klr/df4UQgtQUNm8t/w/419rTnXQvuefimrfRaeoffOnOuZfaR1t/9jJqO3vO0nb33OyI/71x5PUvx4+KfOvQt9Ys2+y1pJ5GtwiEcf5PSMzHIt/8Tne+0g6bhBYcn/QrX7qKmiksRVG+K0a3fK3SXkn8Htet9oLt7brw75WeZr52tjezAhrCRrevyjB4q9M4GF4lmrWvXCebzwWHzhyEg1oF8wdmvK1ZCrApgRkBdnsS7LktupWD8bWa1rPLxHAT+It/oQTejJOt3i/CHaxwEQ5dwfvn6G5z2j23Q9EhXSrv+2BNULnl/yTzy1JT9WtOkcAzfGGN8CedatOYLY54R3kls89y/vNmiVfBF9eupXMDshUYx1ON2sf6oXSDc8VLD4xXa+rTe+lmjDMPylNGJaSCrVs/gFyuCWNzJMCIhSBmcNQxczjMNzcNn9JBFH/MCI8fyjRo6stUqPlGNrHg2xmsZVEyi0Ez5nAKzfJa+eqa++4mtYWSO1mqbbFewZouBfqFmZ+b/Y/oAlMY+jlletIZS2ZnJLu84fA5BMEj2ymZD9JZ0q3kxk2zpRWpi8lotVYvDSQm2tCqdWZGONJEIdgTgscARrOnKAzSt9KetM7FUJnSLRCHY2nMO+hlBXaYInJEAreK2vzqxPM9uZ2p9MRaNfsTTY3TyYTtLymyakcZMgMDVI6Q5vEe5uBb+QiL4i+TN3KAmpCcmCioTX7dE0JmjZVcXki5csQNQoMtuD70PuYtXxmo652XRzylM1vCS8b1Oy4wOd+qFt9S3cU5BkUA7agW/UoFm08C951Nk73axfmapo0vL8LsXOU3FpMGz9PMPu7DOVrGouw08jeTnR9QrYwUdN4nvd2SedhZrhBWs/ifUYI/gnputVHuhEFogcadSt2arAfA0P7C6oT/Ir0P3zuEnSXY4j5cLCPbgD2PUBKvgYCVzyf+ya4tM7/oIYuDECHoy3QvTI+Q6aEii+ZEkLotd7dFn9VKsT2PN22g2w5ozmw5jhGIuVUma+5T6vR1f0JiYRYCGhvwiJE0LnfQxh7v4UGvzchzVsayiJil9SEHYuWdHi6uino1P78OHPubt2q+G60r80Gdz+ES10tQ0LyFaX611CKsnwsvh4JMr6ui81XQ0tMvppSY/H1Y4Dy9U0gNl+gGV1tDqJAbdTs1OBQZOXNpO+huuZhbGDkAaEFwpxGZY3EuHwlIIT4R6gteTFTc1aje/CT86HQ9k8WG7lt38OfzbPuNXJbzuHqzzfHwKd9SWbfNEQhHrbA2CZszObcg7raVbqw3WoWvGbxVWnDYyUo0KSrrdQp+oabjzMRrrqS9A3buU43coHDhP/a9DWELmVHAHGY10Q6BBmuRAnXRDmu1QxXfXRcxui4NrcwXGe6y3DlM1xaTVRcOXJcpEJ3UgFGQGb/ZA2EPYhVFx5IwfgXbwGnWtEjBWrcgJf+Tim4ajELSn1orrlwgaj8gS6Qs2hO6lYkpKBtnNT5f+wKxXQvvM1r3jE3J3xLu/qVRFJeDUYq5NMLQ0Hax8ZtQuIMb2B0yLF4n0tfgQHueuV6rwXsIMdcswPCcAkODwvSZxPe3+lER8CYu/9jYnIWf5HGcAaJmx3sKeEg2cK6M7pVT0JUNS+7kDdRx+n8jq60i0GKptgqNpzja86f1z2BI8+a8xrdE40W/30XLP5C8EyTBsWaSgYFpji8xqE0DCqH4fYJrzmFXeMfGqb4ewwj/bPmOF+3X/eHhPRCb9CsCU7zJwwjYVgTKATC/wC+PcXfdxi6Ma8JwigoT/eH3do90GycxXsWo2w9hisdNA3XxFdu2EpEo3usUd+4wpI+nQyA91gg0BaRotPf0z0BcbLFrOPf7JyQjl32XGIFPdL5Gx4hdXnvx7rHdup3rrgjfYC5Lgj0huP0DSsV2GHkev4C4tMVHuyMgQgUMxux1ZwPoTZREBZdYaOk2Sm2JS+es9xQq0DSDz06lfcPzeXrzmNjMD/VmU/xMJhhJQoLOmOo0L1A1W7R7MaGVmBDjGTdYw0F+sCKgvRpFh8tZK5pgnkt6NPbSqcE0mANBLUGU00rXVdrbkLVGBqwk0Z/CFrKIvOT7/llF4zECEqvQCOArknTWNN4wdvlNcwYcQEXxecduhn7NTP2bTUN8K81UVe7Hle9kXPsjvzjUyz+vlBi54VC79nFKRaorjVrGnUrDnUGlqjvvA2XS5ekT4dxzWG4lHV/uRj+a1sBWAhOY4lfSbQ9PbfHW/cvgWl8Yd3hxSkYJ7W8plm3og4r34Ddnf/ezsTPzvPx1EAKvT3OQQ+9qFuEuSW9WpZjhWUXtr9+OqRbtRgz/m14KzrH9RGOoW1gNk5Xt5asyiuoCHUKU/FtJ8LYAGAsLkzQ+HTSq5lzu5zTrdLH4ahDzcjWCIoXO6nrebucw5Kz0adW/Ino6zy/LET0tfJJ3CR7oZOi/1MhFyLISyL0zZO1U5jbA0jby0UjbWCkdk95FSZfm0y+d7cMxsLLQlS+vTDjf0EpXzQ/Evy6PIs2U8+WztFpvX2fJh2fF3llVtpC9lokjTVrL6GxoojGYLZyAeYPGrEz/IVZ3t+icpevDXOXoyWy6Q+ymaSNGBOJBxH9vamJhgZPojE0eEitbV2FDsdplDqcgIwGkzG4L+WikvlYBP9vksNkPqFqCtUYzU3ujNQuVleJ6ib4IFRY6DOSLyH02TKhEx9BUQOJhWTaheEL3DyJgPrBZUuSQqDXY7j2fqCU0FAioY/lQspGITUlyexrc1L77Wt2DPtqKyxDUlhYgyNEj0qicrNomomUF7at2JoYrngiMVI6qoAvJMoE/FXiJQScqohD2Gyl1OxiW8vSRJlM/juRCk4SC+2PyEIOsi+TSKpaIt73Ld7jUrdC21m0hs4/KFdXJxJxTANxDGIM8pqDNHYcPxui8sAFLoj3II9AAsZ7UhMfoIN4ft6sOTidykPnfRB3+SQRnEwIi6Dl/rPK7WIjzrTYfGY/GWZB16W8D30fMxP/UwmRAVaBt8syieUCb8KyCK8wdsJ5XO1ruIux7AdStdaBBNu6/BYHTsYCX0K9xftuYd0bVMepFs27uhW/SQhLYzlcmm0NdQ2LO1k0Ad2K1Vg7N8BuENm0gmx2eR4Om7W3GMdCkqp+iEeeHyQ8T1FMaAiTLQPIttBWsophrpmcqqHzA7I2Oe5TOs0lI9gaYypZlSsSsxBmlGDizZjlw1kRsUAk/Ct2GXUc3fsFdFcuXaTlPF0Dn38iQwpToUEsH0boeUFV4yV5CajxzWGaD7fpWclqdMYautqH42jBvVCQUOPpy7YHu+QtfQBwJgaET3ChPhT4G+LytvA+E9BZSCfkV+MqsC+V3xYZL3ytq90bmXtrdMu/wYVrHy+bx/C5UPW/sZB/IkSoHy48oMOZVCqv2be4c0semeRjNnefzj+SFLsZip298AAo9rhuRS722LnHdf7sOKLY3bxmh9k36gAYL05GPeO34zldvrkJG7P4StMzAj9+jDQkHpinx7l7gPetOY1FcI37XQzfv8rhxHEP5ecHp5K6tFITrfRElEpPSJVGYKV8XAnUElHDjP/INjxZECrK1m07TbAFKj9CyTUHEgFhcAgWPvxxzMJGVvjQR1R1S6WzKni2ISQOJloSC+gKrmCumQSJB/erceUUTx60LGOWhCtEZLHyBEFFJ7+Box9Jmt7KNH0F0bSu9lkaZgLbPmIrsZ4/R84CPP0RnVH/mVSHRj0+s28Cvef/CC3k+0AduYeUeHrizjm96/qIbprPRwxsUSzww0CMkbvwrMnteXfkzcm7M0+Ys9NkCLUknwyFAsGPZHYLwhgiEa2rWwyD25bZ8CfQ9BE1zJSPwivHJ2BI3TIZ1L799P0w+z4ME+/Nny6D2XcBzr49h+DG/KXSjetq4IaAN+7AGyvugxvPwJ/NPaDulgt4Ix9vPLcIbuTiRP6/4M8WPCUXuB5v7LhXQnXjr+DGTDDHQLdDisb7PyA13npQ0fgjS6XGjxzEdb6TvDeI69jbcfsk8KuDKO3dFjARPIYDUtqGz1Zuwfn15l1LjJyhIXD1cLp/g3c3+wCWt8lAFioN+wNTiaxXpi/S0LWucrIYmCqdzMnd60nVpcbx/kdICV23uGAPXJumxYpS8XoRvdbidRVBozzOE/HmIbW0AMw9Fnbe7hKNXODND6muEeG214G2LeT1C+KHlKwMRlZaTLIy5GSlycjKkJGlj0JWs4lLXW4Mb2xtI+J860O6qEMRsYrSiZybUNb+O9KreC+u+DcXpJODpU0F6VUQCGrT95FFvQZPD1xVPa1h22iB1g/AmcejkTZoaA+3BwdOuQ0LrjRn7iFliCoaAD2wIQOZvQ2BZ9AaIgthvkNktQTa8OEWXe4R8JuxQDSuxpZEVl1xAAJ3P/Jodanxum5csIvZq8PesQrPbuBFOa6tRmFEvc4KcW31bD05NEMXiruumc3CnHdlAgE116avg3TR43PJsJFyDnNZDMgkrDz6Ad0xwVKzgQuU6FGU6H1M+6noEPUHgNPIvuGfD1JOE02Gfwenm727lPuG21GTgQrE7G00exPScRfPDPPlVIs3F1erEyEM6DVmOoMuoCdw8IIu/nntuMss6rFQyNMLAhw5x0LIPXaAhosjB8iCIncazGTbHvizpaHKSLaU/g50b99YDeBXcB9ipxvu3Yr0jD+guGFeADdwxydwrfLG3R7pRmfljT1LpBtfvQ83iFH+/n22y/BY+gYNXf+Sy52dsttAGKQHxuq+RAlFsA53S1j/C7HqgKzAzeGryeGrG99XEHN8oVStNExM5/dR4jsx1j7QH3Q1OyKXI4HHP5CKfbY/XGzdtVCsoU5WbEG42NZIMUMbbNPDxX4XKda5TbEMtAFc/qxp6hH21d+i7hSRZx2NPN0X9qCR52bAGdgK3ARefZ9aIQkDfVBUeP45cPo9XIJFeXp6yYRSK0rKno5U+bJJkJHafe09hbt+coAa8dXoGERpxGPr9lOPLZN7LNtskTmtjjgtVS31W8oGdd2LWIHKh83NSW1D3T/fw3F/SFd74DzyOQC3TTOkDRji3/7xCfyyZsz6Xk7A2FXzjibwDAgr2AflfnpfRGxkl3lHoN/+y4qQH+5rX4T80/5oEXLFfoXIHe9TkV8pi5BXAa+GE8FZ8oOD6gjZlfcWks0KIN5EQyRcRAuRbTYZfIkVxYoQ6SnuaIh074sRIm97TxYiK99VhMj791NWEwyHg1NwbyhKhJyyj0RIckAUjznkA/eZuPediHvfMKnK1+JCOtv5pacvvHdqscRAujveW3mk9I136fiuEVIwrAA4dsS7cXC3Bv3Gu9twuCVIkO3G/XAywFsFVQjlaD5fvYPEx2rFxlq5/V06YnQD0pc0LX+QMDLVdg6MgwLBeAJL/OJmhRZO3dxRLZx4J4YWDrwr08Kxt1mTSNjH+5Aw7Etmkr5E7F172DMFp+mt7BBsHW5ytXyLUxB5L7PsHdrLLIa09rD4dvAqwoQ8TNz5DmW+5zv0WG0YowMxPgl/ggnBuCCRCEj0FNDVkpFAJBQZVfd6hwkdh9ZL3mZO/zqdmuphKLyRU1GG/JH+D/E9QiUO2nykjey3vR2R/V1FCtm7izoq+3vejiH72e/IZH/3W1KTYBx3vouyR3RpDB0Z9OU2eyYhsJwBFzHgfFIynpWMJ0BdHa6Z1IJMHyYSmQQSqX0UJ0fr0Xs+eYtOiFSoxL8HewMNtG31vT8E/spqqdoS1wT7h2up6ahdBB1VoOItNAZdrTskY/Pqt8hMCpykr8V7GiZTZv8kpqrxb1ELGfUWm8DSBYhOyURVYV+re5MW+xSKtSSh8fTDP+uh7ZbcRGXZW99UGJs4gZ5qGas41bLrTXqqZeubVGmt7AR+MFWOKoWhOs1QDaWoBilQLWao7mGoTkuPekHFwMUqGlnFHFYxIKvIDqCTpx207GkH4g1DWKV4VumQrNKei7W2fy+tuHcvrbiHVSSn0RYmSSfBdXV347XyNPije+nEdtVe5WlwCyj33rdItIycqvoAV0vPkl5+d8tXGuZz0l0LqqyKPHixmyicTehr3wM1tvwrUVV8I0SDlrcotGUXpCRYtJxJiCBgBygq0oukJauWThIaPLBWY0wLicN4H46w8dIcvtTVPq84D9YHKb8pfLxOOo235g20giXpRYFV5IrV9rxKLn1pFt8irSX3R/Emi29kYd0Z8Tpq63qFoRe/QS146huqw1xHPHsYnvBBretIM+PTA/3l7enqZoRYtp1tHtlD2zy459JtvrSHtfnMno6cDluyh1qVuEd2OiyiFrJ+oqtbhUp/Pz6sFP3lKiVyBDl+D1WKPnC2+bKVsq2ZCuiV5ksL6OFmJiBv809SyhTW5sR2tNlfavOq5o4o5VgTVcqRJrVSJGfD17u1eOLCCsnogEIGoEJy46hCMsIKqW6iCskIlDddtkKGNVHhDGq6tHA0TUw4rbt/kkI276Ztvrj70m36d7M2a3dHV4iudgCZpuVjJO1BrFammGm7qWIm7ZYppgVPwwZpOAOXYZ3PqcBvdrEuURHb5Aulg8hCKT7HJFsCPb5LtgT66S62miim0WXUUXQZdQo1BFEIutWL4LftpoOnJ3dJa6NvRdZG/bvoqLZul7Q2+kp4bfSeXVSOjl3R1kaLd9EuZOou2droP7rQPmQMqLKM7PdEHs+r+RK64u/N3guyqdG0Jnos8E6YK+AYsWZ3qsWbQcaDPrak22cnOxNKzo606hb0xxPfWnou8B+7aV+FRwPxPkwm8BG7gXgK2tM176HkvBUmLtgdZiNZQJbFe8Hi/VfAsZOeMdaSqYbvCjzMp36Qzuztz9fsSg0v8O7c/ht8ljCFENMUHk9s20FFhPqn/M6UMwzztW/M3nO899g2L1Y/dQEtYEghPjBXQHro+3D1+jViBnhOGOAmsqXpIRsVQDMwuXmXdAj0vzlqfyiffljf22QBbbPSfPMOXFsI3Ep0ulMm5mO72Immh+mIuVBzwaL5kc7zTZwl8xtyhgzmlSDhH1Or+xIJ08aXoPLZ7FRr9hamouuUQzGNp4Seu7zdTKZtlH7PmJaHlc/I3U3bFnF4KrVoZs/I5eFDcsEhJsMJOuW6LTiGHr/kvR8HdjQyNUENrdlXyNFDlya2kCAdpzPRaCmfqm1qpEa9oTHy8Kj8/P9OJo3nyKCj+eKPqFm8penGQu/4dKK1Vbj76MeHzugzZjkmw78t3groHb1L8NC6mM4HsyK7b2Xh581gnEx2Tnlvhtn7CV8DUxZQIu7bbVsJprE5gY6+0D4zd5AVdALHdQVt4FV8PNOH6sGAdC3ZlhzJ+6aijvAs/e930KNm2dE6j2caaIx6soHGKC09S11IHiHIPKr79Zl4+rDAXEvm57zfkp5GnkEw40nz3ACvmxTASXEn0nQjKQqahqEkBKDzqdX9CIW89wuwlSJGBjgVnjpFTFBziEXzGR768vR46Aowl77q/dZm9kDA/u0szOOSKTE3VLjMkgbuoJY0NPJELCnG+0ugpdz3xJG89wq0mDSMA8Eh7LwrkkfIJdJ4DFqBcDAuTENqHCrfh21iOPCWQHGQUipbXElrExpIdPqQTJ6zyLk4/oYM6BrAtQvBF70BS2YrPqmIz27XNYDaww9STPH3yI48SMHn7uV1k9+zaE7zuonv8XX7senZ4kLeP/4D8jTFNdtJ4Jvq7fst722xZJ4V7+JrGlu9exoD8eS81NFkscqw33BG8Tw0BOiDZu/4A+bmhIPUQZpa6Rb1Ps9nYF185tcWf3WrxdvKZ57ma87muMe3YEGw40hLnkcLSYxFg0V263rhEKEvOePwL6wK9XS/JidSanYAtx9GSOB94K/TQIQsx2M2VdrngDwEgGlpYWfz8WmQx8fY0lheD/kMyfkgD+4yLVt68hry2ZDPgXw2y+dA3gh58nIkc02TEUzDCIarq7snhM+Ing8OUvrjkcCa13GhyETfq4y+mXsCRhLsyYqT1IeOyXzozUAZ1AjuQnuFFlIt0H9nSMKhj4SZXqfPXRYVeq/Dh1LJQUqzf+guenISxgG8wvPrks5hp0rWmcwQvMzh4PXjVuxSTgW+2YpRf1e5co9REY3qqn9UrI5HFtUnbVXciKwQD8MbpCvLx6urPVDktYW4TPYvQ0PgiddjbBaceQ34v0fq+ZC8Xa+R0QSOilZz9CxzJACP3UoD8PCtyqf3B2yj+wYg5uuomPWKUBV6jYaq77G5RBxCNZGDCoGkJGl0SgZI+vBINTxKIvSQ0eqW12ifvBGYKatXvB8gDSLn0vszoMsdTeYu3/PeH3nf/dmkQ+0Ur3qK489bpX732nhFl4b2g4Ho+lhdmrqXwieiTpD+1eIdYvZN1pPuB1/NbvGXpqcq7NMHI6Bj2/AdWoGqrayjOqzsUtNeZ/AbyRGI3Rhu0Cy92TggO76ZbU0kpGOngx16Lx77CQzR64lmsDvHCE178+tJb95T94olPRUCdB9FPCH98RfYH4/YIsVnE5g37Y7VC8+kj/ybRhrBzMQOKpC7mZmKpyeaCT3m3mMLNZEuW3Ctn0lkooY+h3LLa/hwjK5uqoahrCRPGJhYt7WXb/zhJn7gXl6zV/fKHanytfbzr1HV5MgW1nXb3mdH8k8Fhm1peyQ/2FV23tFwYttD2O+CIPO+I+vBEOzJbGtUOh5zrn2DWPtMrfmGWVrPQIjb4gizbwwyFqjfTMh+ZCedlXQNXlNWbzhMMuLVRAJiTu1hcUZwwUsaWuR4vWLmEtpETff7TRG/oZLbo3SwDzdR6b2zCVfnPIMlCda9fj7GPuAorLFsF3qALKJEjRGdNsWIKqdflba/Hn01vP11RTzb/gr2pvfujdy7SaveaOsK8g/SdwMcCex7lc5MtFvI40LhiVL5q7gmfMJTEnxADr4ZwEEj2aBCkYyJGFPzq1Qc27FEfywB446etJhOJjnPB8FDNOgOVgbd5a/SoHv/q9LUoJmth4UCd22Wn6fC96HAHIb3CUb0nWQSxsSRZt+dOZgvoWGtUBHWMl6lYU3/KvY7k0hPFbxeUSSRFTn/CilipGM0gtPzHFxkyxobDnk95ovoWqI5vJZ45BWK5VWKRR+locdYkUdokWzWEOLzbICLVFlDWultLcrn3xmGGRQD7cdZwbL6Ygypzclkd6+mWRuw0Ge4AgXEYo/c3tLnFcXzNuryfVn5HlL54N8V5cPhHCY+2Pv+CmbDMDEVQSdm34BCnwt686BnYHBy+PzrscC6v6sWAj4VB1l81+JM8RR7XcYxxQLp3oAHqgR30k1IulJg+zs11tv/TnaZyDvCw7NDmX0gfaSzWUNWSi9IzMEwWU/3Oc++jDNmzE7DTXfkmLSH+5Sp+DxyeJTehONQC65dFkJMI72eEYe8PO5E6nEn0nuM7EP2BKEGB+K0rQoj19XQQrA7H76Pm5Lf/F2xKXngFRoo03FuTfowXBiBTiH3I/FaMz41hkNicnwh2AtXSOgG0JyXcZ/438FRdI+Szc/IXFpNNznaIJ1xkLYlPxijZy8u8HX95xhpR8aSoMe6GXQvZgkw4WeLIsTiAi/RmUsG3YXBDdoPXqarDngcMxDYqNiEPPt3ytqsGBuQb7yk3oC0eAfK3swTawcSX6rTNZgFEZ1mQE7UePqoVtdzXqJLI9kvEVNZiupftgvtAS0G7QVDlOS0nV+S7UFWbsTQ929d7VousoBP9rmUTXywkTbxNqTBhQQdVVHnwJaNdKcGQIlloyPirh7dTnEv3thG3GUvycS9+EXWAHZVFS9TtyiAFMfHbfyfvQYK71P/36jwZzI+Q3chpyHI4QbxVhJg09CcM8KvO3ofqcq9Iz1DTAFhriPCJH0Yuk02HkckzvUYELdtAA5cM1kk6b2RPLimPjUR6dZ6vYhBH9cEPQPos4HSWYOa5myfmFCEpwwKQALBNMT30AbqvtnsiMEWqA4Gr72OAnHitAVNJ/DnF6Xucv4G0iVaoEAaLhSoZpjo4XPDpxCWstcdaANFUC04hu1dWGA+ITt/oCV+33+j7PyBVnJ1LUCNf9dI62SBnI142GAbvjJ2C37PgLy/ayN7khfqWXJDYv/Ar7G1q+WwxIATYMbaE2JXrDJwA9U7FEjsOlLPXhvg69prZMSwspGzHGlPlbLCnr8jttVvA7WtHMm2qgKdX2SnNlBS/V6gI6DvXkRzKmhXPH36BSme7sPjQfgqv8CgDT8pnjZtUMTT5ufbxtO/bFDE09oXLyuedn3hp8XTOkPEwX9jaKeDr3m+jYPXvSBz8DXrFfH06Q0Xj6eLn/8Px9PAehrsjq4PH/C4SDzdsl4WT/utb188rWNN3Le+TTy9a30knvbMjoj7mux2ijtzfRtx93xeJu7M52TxtO8LNJ5++zyNpzjeXPpABodvvPgh3j2KpyN9cQaZ/ZJRV0vGeinQXHg2PPZ2fw9ikI/L/xW5N5lTj8s9z8eYN5x7lg7Ym7DUgOeod95CiFvazvFOp+ck/7xrCTsIHKh77if55+D1Cv+87tm2/hm/XuGf/15/Wf5Z+exP88/Ph0UM5qth7TSY1mfaGMznz8oMpvVphX92Wn9x//zomf+wf/LPUOcxPtMe/+z9jMw/73u6ff75+dO0iU+fbuOfe5+O+OeCoRFx/3poO8XtfbqNuBc8IxO3d53MP5c8S/2z5Nno4507vmHjnGJSoM398fR+YNSzrNwVTyvHQ7z3c2lIRF9z+A04VW2DOFSXWYcv5NVl+otI8ru5JHm8iiT2pbrMynpdpmetLvO+DRZvHb6s1+L154Swnz/G+yfq+Jqjp82ZwMU53l+H7+rlvaZ9ZGbsNe3hN+nZG5Uh1wDQBnxM1fshrrZ4G0Pv87ZDuE5h9ibx3jlH6aKS33MURALueAsqHu74Co+S1V6YM/Uhi0rJeQ/pVmiDKWQV6QKuIn35NxxsmaDcJK3Zl4KLSLhK5bcHpOEcxKfvn1bEF7P3IE75LP5BZzL13EzeP+wCpMV53vNm7xnctMB3MDeejw+4/kpP8OkNh8PPP3l/sHjPFHhP5YV6fEJflfCp5ziJnHPC07f6iAK+2cne6cze4ozfDxheal8w3C2WOpxc9RD8/AM3vNxVaR/udNzlGF7pcDpsLmepdeRwu3OBe7hVtLlK7dX4fcLhVYvFcpdzZFbOcLdDtA+rstruts63uwm82upk9x224R7RUeEe7i63VttLhWp7WVZ5VRWX7/JUlDqvE/X4aQt9maPCrudK9NdnWJ0u5+JKl8etd1or7W7Aas8cN07CNW4cQTZuXATbeKB93Dj21Y5x4+Rf7RiPH+yYoJ8wbhw0Um0VXdXDJmRk6sl3e/S3l+hv1F+q7hygafBl0HTJKviNKKgiIOMy+q5XktchNHM4Of3jxtFvzVwmAx0R6vUdlekg9zi9IFS53PqMheUOW7ne4dYPuteTqZ+gF8sd7mET3I577YBUeZczD5+up206XE49/E8+X1JKjOen2M4Cuw24GF/hcs4fSqlnn8hiQGD2kjbUDhxzOFpo3Dj2nSbO4VxgrXCU6ivAf6qtFfoyV7UeCwP+hQ6xXI/fY9Ibssdd9zNw115TAk21YaADdTsgq/85iuZw+s7wf9dOKg+Rf8NL7/RUVOidLlFPdKIq6fbMg0tuEoYpLEODFqgLv5kDJS5TQe1lo9q6ULBWV1sXS7YUW8KXiXIOlwG/efoJN+qzM/U3ARr9eKYup6fSXg2yqHBUOkT3+FK7rQJxZMzLBDIqrYug/WH6eZn6cfqMdpR3OGl5RG/NhJ9+8GD9Na4F9uqyCtdCva3cbrv7mp+9C5KkJQy3lpaS/ge5vrSwwvXA+EpLM6h7499MLhs5cCL1Tv14falVtEpx62ennqgMqrhFQjpmkVw9QsaXTMCAUmavtjtt9narn1Qlmo8wefscwmAmNSS8nAMhap7L4ywVHM5Sh83uzmDpf4pHQII2qWSTWBVczquwCw4W1RxuIEm0z4ewOb5kMTABXuuxD9VDbzeBMtluUbA2Wexub60qcOMq+/iIRRCvLLO6xQzqjRRpyeKhekLaBP1gmWCH6quKO+CsbRsDTheHlVRt5bAPzMKvfGWgI+rNrGexVs8Hb3SKWZyruhRu2RdVQfCFPtOqx77YCtcQXOd5RD2NdHpXmZ5+O1LPQXwDzXODKkr/x6IbqPRnDm6IcQ71VQf6qgN8lRjQfLs4PntChkAk+/Obs8Npq/CU2qOYNQREHJeBUvR4c0KH7RRYuiwzVUg27OtUuoOpfAnqy7XMsJyBuUV6q7OUXckEXgiR3zIhg8m8fSFY4t5VVuYGFCNkTGRkMl8r1g8eqle7XeGECBR4Ghy2JAvwN2KoviNs/nwxgjkukXQhJeQnhgKF2NHEo0nd8NOkbvh5pG74f0nq/z+bL4X9r0ry/xGT/HklKX332zBCmGyZPjHPIgjTBEOOVHc0qTrWPN2EH2M1XaKcYYzJucBR7XLiCKJ9NUYWi1YUUWm7iueapC+5XhrxRJgLy4qz7+ex70oOqTMqvicpwTUMPpelEnx/Lc0vUsHXMni9Cr6IwdfVKb9P3sDyuNFAvqNmY3SovmM+V1WOK1WWuwTz2bNwBMlEKqcrY7mS3vB385ar6JrfkfZyS+CvrLVIe2titLdH1d7RKmV7mj7xNxxg30Q89JtQCF9RVv67UAi/BLcGUnwIcQ+keAh3xaOhEL6EbA2ka+F+zu9DoX2QHnonFEqPh3LvhkIVkM4+GAo1QLruMOSh/J5PoDykrZBuhTTj01DoEMIh7ZEA6VFIAU8rpLMhn/ZZKLQG0y9CoU8g3QRpl0RIW4A+bA9SC36t9XgoVATwtGAohG8QWwHpHvaxT+mbk5p7Z3CaRamaPl2StfWa5NRU9t3GtY+EQtJ3BaOXpd/FxLJPQVnpW6TpbLV6bX0oVI9He1JSJ6WkTdFdsVC7lLup9w3Xj0wnn2HEurPRDkB20ndGsV4Ffsf141CoP+56TExJzUtJy0vR18Svios7gZepE1O0ALBL13g8Gfco9CBL8l1GANfECSla9n3LrYgvyj087EXW8eEePsWLbU1MSZuYop+YkpGXkl2TtDLRn7AqfnVcXG1KBgGnkSJaihcfOXruH9HbRBtZeiwU6he+d0v4ngXu1R5rWw9ljM8Htz4cCg1k9/BO37DsiyxE+snx+/oYuXhJB0OZzE//NhT6LX7jNbDSqJLbdJncuCIoU4J+DTr741go3wrl82S8T0zJzkvJmZxyOqkmeWWSP3FVwur45XHxFdek5IBYJspkkYcYT4PyCjC+wL/n3gyFjiMNFauMankWpBhlIn0RG1FINS/FSGhDfyp5KxRalQx4aldFo60gZa1GQVt+UnTa0KcQJ74sqf79UGgS+EpCw6ro/O7TKnDGxUfHuU9Lv9OLu2jPfRQKnSNfOV4t4xcYm5zSEF+TuJLwGp8ahwKQc4q+j99w/QRjBfh8H8ShXy2ji+DYBzgoNU4ZBkpFPNLQF+ot+gejge84DWg7c6HuqH+GQvi+hITy1SrbuUMyHROYDuG7Hso/9U/WZu3ltXkA6m74dyjUCfhPeIryvTwuv2uShTIcdxqMO69LEsYItK2loLf6z0MhO/PT1XGAdFU80ORPAAWtTORTspcn8Sk5NcmFKcZqojiVeZF4swdj5eeRWEW+AxrSdEHn66G9heu7kORPxXFfAmVfaro/OZf7V1zXgwLXkNR9s43bn9T9Lzbus2TtfoH7WLug/i5uX6dXgacHu3Z/yMb9oWv3b+dx61O0bwvcFt2CUBm3IRXvHruy+5fzuLNXdv9wHue/SrtH4P7Yc8FxG1d/9XKw8Uf73/Gmjds3oPezAnd8wNtQ/tVru/2xkls9qNuaSu7dvJ47bZxvoq7RxjVMHALXJyYOges1+TXAy39N7n/yTm7z5L6Nd3Jv8gN9d3L7zd0fnMN9a+76yB3c81P4pXdwDxV2/uvt3NnC7mdu53zT8ADU7umdgf53p3cGOj+a3hno+Wz6YI7zFmkfvZ37TVF3IOcvRV1BQ0XaR27nNhHAXgQcLNI+fDt3hAC+QsCFIm397dzymxGw9ubhn97GvXtzItB44OZEoPGjmy0Aeb24u+82blnJNWtu5faV8LW3cs/d0nnjbO7R2d3XzebWzf66J5F5j2Ldfg03rwyUpOkMV/s1aQQ+mtuNJGt0n3TlDmjOgOb2JujeTuG+StS9mcItTXoDIG9oE/+cwv2la/+Pu3KNXd/WSHodtzyu67pk7rdx0KeE4rTvJXM1Canbk7mNCV2/Sea2J/wJ6n6apP1dMvd5EljA2STtb5O5Zcm7Nax+nzRdSyJ3XY8ViZxz+HcJ3OPxnf+awP0t/oM4en8gBtISn+bFeO6IBkLpo3ETwSsOxw2Efu9c3BNhOi6Fpyd+0Ha0drmGuxHIuFlbq+FuNbazbir3LLTzrCZlWRy3WVPE/fL75ffL75ffL79ffr/8fvn98vvl98vvl99/7Le0H10nrWLrpUX9jL8I5f+inyZGejBJmf+nKn+B5btI+wlpVO9dWf6RaprvxfIZbB2+D8unsrQ3S3PYfWm9U8vS7y6EXGT9Po7iY8vXnLETzUtrx63sfmepPkNwBcunsfQqFf/x0sVa2r60NmRUrZMns/Rqye6vNCrg9d2NCrqllxN2UrV/IUT52dfNyNYHaF6i4zTL893+d/0owPaj1L8zTM9JvWjak6WDWTqGpZNYOoulZSxdwNLlLH2UpX9l6SssbWLphyz9gqVnWJrUm7XP0sEsHcPSSSydxdIyli5g6XKWPsrSv7L0FZY2sfRDln7B0jMsTerD2mfpYJaOYekkls5iaRlLF7B0OUsfZelfWfoKS5tY+iFLv2DpGZYmsXjbk6WDWTqGpZNYOoulZX2j29Pk/Pxx+oyZ8zxO0aPPyRqVlT3M4CE5w/2GnKzsUZkUytkqrM75+gX2ajceYTZkZ8F/w0YpimaN0F/UpuIheuTEGaPA47iSqPB4TowKTwjHAyU8MRwHlPCkcLxQwpOj+lk8ePG+qPBOYT9XwjuH44ESfkU4LirhXbijUeFdw/2oEp4SjqdKuI5bGxWeymkfjAbvxh2NCu/O4bZRW/iV4bithPcIx2sl/CrOGBXeM2o8iYdoGngiGjwtHI+V8F7coT9Hg0Mv8mQ0eJ82sE843K/5KhS9H2wrhysZHLd45L/BDK5XwXMZnFfBLQxeroILDF6rglcz+FMqeB2Dt6ro/D2D49ab/Pe0hF8Ff43BG1Twt0kfGLHDgQz+GYPvY/v/51hHeY2Gwdk+/SBWvpjBpfMCEvxBBpf22/tJ9DD40ZkUfpzBv2BwfSWF/4HBcT8c4RvmUXh/NjCZwOD6u5R0Lmbwhkol/GUGl84/SHT+k8Gl8wASPDWewrMZX48yeGk82lBvrvtf5irGSatY+X2zaPlVbMAwMIHC597J4nUChW9jcK6cwvswOvFNuwg39qdw3LvFX3kibbebqt2FBK4Ln6eQxh9/Y3DpXIcE/5jB61XwrkkUvk4Fz2fwBhXcxeCLVPDHGXyPip43GVw6DzKUwX9kcOl8zHAGz0qmcOkcjAS3Mrh0DmaE5BcMLp2DyWDwnQwunbO5nsG/YnDpvIgEH6Cl8KrlSjzTGZxTwX/N4IfqlPDnGfyoqvwn2uhx6ZiW2aGqX2hh8FTVfOscg6vnYd07UTtJVdnJQAJvG8/5ThTPUhWeElK+bb8Qi343Kd+N+3eU/iVa+WWd6OxA3X89QvC07Uce70SjtJr+5xlcTWcjwdO2fznYiUT5Nr/jMeDnY8B7dkbqe3EBVT/VD+DdZP2jJP+xnaPj2QcmpY/S362MUf45gj8yHkiQ4mqM8u8SeFduLdPvbxn8QIzyZ2PA06+IDr8X4N3ienFHVfQ/GKP80wxe30up94YrsA+6iuOZ3JYy+A8x8FzVJTo8Owb8thjwJT0Q3nbc9SssHwfxnPmjNF/8bQw8f40BT+4aHT4wBnx0DPgBHdMjo0c6szUnRvl7YsBrGbyot5LfZ2KU39qV6mUP04s08u+SEr18VTeEtx0PD0ihdqL2lyEx8KyIAd8cA56qiw6/NgZ8dAz4bTr0r8g4M5U58D0xytfpqHwCTD6zGXxLjPLv6GjcUPv7050Q3ptL+4sSfjgGnlMx4F1To8P1qRS/Wv5DY5QXYsBfS6V2WN9PuS7zYYzyP8aAl3SLDi/rRvHrmT/aGXxBjPJNMeAfxYCP7R4d/mgM+LMMvq+P0p7filF+6JXR4R6AX4P9+D0UTydmVydjlE/qER3ePwa8ugfTS7UyXv06Rvm/xIDv6EHtWTqnLK3fHe0R8X2FHTI86vPEPa6ieIoYHmkcOJbByx9Xxvmaq6LT8xSDz1XPlyfn5wt2ctpaEPG5O0NbSHZb0Ii2oJFtQaPagka3BY1tA2qLvS3ytrhHc+GTzm7PPMEslI7IslVVccJt7T90nT/CPCVvRK5gM5lMBVUzppYIHapekG1acOkKyhPul1VnRDvqjHSLwI+paKrtkkVH4UOFo/ChQlNFRftKt4sE6fkDKtYxHRGrourIkZdTtV2SjRyBv1Rx8tijITvy2KO5WBxDn3A3TyvOFiJSNxVbzcWjBaT44lLKmedxVIgOp3vUNJfTbsKSUy9VFBsYW+ZxYruj3VUVDtFWYZ6iIgCbLrFVuKuj1zfRiu4qLAKAUtPYMlf1Qmt1qblEMJVVEdKrphfnCO0iiRiERFMOPihf4XDakawZEbpIoYsRRguEq1+SuNz2ESfRNcrhFAWgaUYbUVVMLwmjEtjznRA8RlVa8dlO86W9DHAg0lEIQBoNhmq721MBcQlta3rxWERfLFpyBMHhcjgdImRLzB15FKQd5dXPzbSniuoZnnZUifKg0KVrRR5DunTZ3A6xIH+ABUoXd1CmxR2XaXHHZVp8WTIt7oBMizsk0+IOyXRWB2U6q+MyndUBVme1n3hbtegWPWVlWTau1F5tn+9wi/ZqQayEKADR1s0JQqlLmF/hmmetEEohQrgFq2cRZ3NVVlXYRXtp1tjc3LHRCwll4MX0uXMBlFa9mCurtlbahVJPZeViqCLLCejviqKCMGlGXqFJME0rECAwCJOnzRRMPAPyBTM4oeDWaXmF5ny4p6hcqgS4RWu1GB7zTJ80qdhUIpTkTbSYBK5MtFdUGI2TLeaJ+cKIrBFZMDi6zWmtZKDZs4WRWaMw5hW7RlZ5RJNNdcOOb7kgQWus0wUB0bWwbU1xLHv1j2GE/BUqZluxaDDgOwcEsdoKnYzZhv0h9N+5QqFAX1WEgxIlLVkjDBRpjsPlFvB1ONh1qho1TxfI66sEj9teykFzFXankkkM2RySZRXYK2TsbIwItmY0Aqa8iWbBkDWS8DYiWxAIcwJ9E4JgR8MB2n4uZt1ux3ynacbU4lFCW26FUrdLKIdgUWGHJkorihZAQTGXyVsQlUQscDuroEWxTK3VkllAwugwUXZr5TxPWTS6TCqukDx7tSiUWR1tTAXsYnRZhcdd3kYHIDZDblhsrvnQagypES2UVdtjaqC0AkZRTElgzCKgqnLY8cVktqrFEYoMag3kUmZdVAWU59iKyDeY4NZIwQx2NR2Mr9JVao+iDGIyon2RQ1TLAjUTxW9QwTC8AAmaK0ymGcWuEpWOc7ky8tqqNm64MIobAoXVHqfogLBBxFlgUEt+nq2yqo3uSy5fLqY2QijDCYCqCaGkMF+KVKj6MQLBD5gl5qNZ2gzkJ0IN0gGhKVswFY8RiqYWjxQq1KLC4VexONpGhlA2E+irUFjoKLU7ScRTySLLYLg8p4SuQ/YiKFOlra0M8H1PShmgCasFTyVBnWCetVSwWd1iFE8ZZXN5RDW41NrWnrBbyybMWOc5FhgwMLkd0E+Bi5JBJEihzGVSuE8lCXBqdWHcZj0DMCm6oni2OAZ9DmZwbUysDMfeaozzgATW1WDIHCWxDZwJrjIBxsrz7UJZpQgB4F6VOLOZWjusppHQv5ZCJ1vtxjZIbxG1u1CN2Eeap02yVdAZl6wnGWUGE8o3mBb8DGEdtFQIUauqwmqzmyoro/ZjZXaXOkoLFY55NsHm9ghs+H8ZTY9lL5MzRWlxvl10R9G0KqiADGZMvYyWTVFlfxnCG0P0ClYtCtDNxVYtdAGVrgVqrxPmL1okVNmr3S6nFWavi4UF2aou/bKIGisztotSRUTKgizYVtTIN9pWYbdWY48zgvQ48A96Nnsby4MudL7TQygFExZdwiJG5+WoB/6VCEWTHEUQYsEkYdpeBAFUWGAV8OVfgmidb6osnijcy7o5Np6TS26mcyEKYQZMWyuR2Px8IDT78kc+Nogkot00I5oUI76Ao2gmVbt8aUs9kCAVSAwScIDXphc0yxGoK8+vdDlZZYGZSKTwqIXlVrFtYECMKt+JErFlohktF02M8VdsX4IRwcWGflGiWdvYzWW5F1eK1nmQQtwnabl0he9Pq67isgC/PQt0PgwsguXACLNwpaR0mKOUI7lyq7ucyypd7AR8NBWr6R12mE2REeAeDOKsWJBdVVWI2CSEuSwYT8FfouasaheZU2TZy9n0qLy0OpIDpDabYjmX4qBzHYpDukY82BSgJARaKx02qO8SyR/aPm0L+i4uCyZ0OLP+ec559mF70dK+gHQ+L4cB+sY4LxzeR2NnYKX60jm+EgbQt9nzV/4MqvrSeT+RAdIvUR+fDz8TCrmk+tK5wDUMIO1qJarOFUu/aeyMcJzqHHErA/BsIyuJ8a5Vneedxc7uxqnOJRs7Kc8hx5LfnewMsFRfOo/Id6P55Sr641Tp3exMsZSXzi3uY/UbuAj98VH4v5fJNE51jrm+u/Ics1p+Ev+1rP5E1bnopVcqz1Ensjrq+quYTJJU58gb0pTnrWPp36uqL52rPMrq18er9oNV6SOq+tK5typm+NfMil5f+v1RVV86L/BItfL8dyz616r8Tzq/sZbVL++hLK/W3zpVfencjPZBdj7gEu2/oqovnQ89yuprEy/efoOqvnR+MrCS2WPcxdvfD/9SZOffpfM6GY9Fl7dWlf4D/ulk9aVzQDmPRadXXf84o1+qL53PMbL661QOq45n38t8S35uPvC40lGTVO2mygKCvH3pPGzgifbxn6iqHz7XtJYmhzQXr5+iqi+dPzj054u3H97P1VBYuH12PiLA6qddQn69WPvZ6ucPWP2iGP2PPI2L0q/lPMniEWMAz5nOiRJ/Oslpl/02baTpG1ddPH53i1F/2Z7I+diL1f8/jaE5rWjRAAA='
    bin = gzip.decompress(base64.b64decode(gz))
    with open(pymain, "wb") as f:
        f.write(bin)
    os.chmod(pymain, 0o775)


# compiled by pythran
"""
#pythran export main2()
import numpy as np
i4 = np.int32
i8 = np.int64

INF = 1000000000

def q_push(h1, w1, p, sh, sw):
    sh[p] = h1
    sw[p] = w1
    p += 1
    return p

def solve(a, ch, cw):
    sh1 = np.empty(1000000, i8)
    sw1 = np.empty(1000000, i8)
    p1 = 0
    sh2 = np.empty(1000000, i8)
    sw2 = np.empty(1000000, i8)
    p2 = 0

    dis = 0
    a[ch, cw] = dis
    sh1[p1] = ch
    sw1[p1] = cw
    p1 += 1

    while True:
        while p1 > 0:
            p1 -= 1
            h = sh1[p1]
            w = sw1[p1]
            for i in range(-2, 3):
                for j in range(-2, 3):
                    if ((i == 1 or i == -1) and j == 0) or (i == 0 and (j == 1 or j == -1)):
                        if a[h + i, w + j] > dis:
                            a[h + i, w + j] = dis
                            p1 = q_push(h + i, w + j, p1, sh1, sw1)
                    else:
                        if a[h + i, w + j] > dis + 1:
                            a[h + i, w + j] = dis + 1
                            p2 = q_push(h + i, w + j, p2, sh2, sw2)

        dis += 1
        for i in range(p2):
            if a[sh2[i], sw2[i]] == dis:
                sh1[p1] = sh2[i]
                sw1[p1] = sw2[i]
                p1 += 1
        p2 = 0

        if p1 == 0:
            break

def main(in_file):
    stdin = open(in_file)
    H, W = [int(x) for x in stdin.readline().split()]
    ch, cw = [int(x) for x in stdin.readline().split()]
    dh, dw = [int(x) for x in stdin.readline().split()]
    a = np.empty((H + 4, W + 4), i8)
    for i in range(H + 4):
        for j in range(W + 4):
            a[i, j] = -1
    t = stdin.read()
    m = 0
    for i in range(2, H + 2):
        for j in range(2, W + 3):
            if ord(t[m]) == 46:
                a[i, j] = INF
            m += 1
    solve(a, ch + 1, cw + 1)
    ans = a[dh + 1, dw + 1]
    if ans == INF:
        print(-1)
    else:
        print(ans)

def main2():
    main('/dev/stdin')

"""
import os, sys
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
if len(sys.argv) == 1:
    import subprocess
    if p == "":
        pymain = "./" + pymain
    subprocess.call(pymain)
else:
    import gzip, base64, stat
    gz = b'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'
    bin = gzip.decompress(base64.b64decode(gz))
    with open(pymain, "wb") as f:
        f.write(bin)
    os.chmod(pymain, 0o775)


from queue import PriorityQueue as pq
import sys

mod = 10**9 + 7
input = sys.stdin.readline

delta_u = [(1, 0), (0, 1), (-1, 0), (0, -1)]
delta2_u = [(-1, -1), (-1, 1), (1, -1), (1, 1), (-2, -2), (-2, -1), (-2, 0), (-2, 1), (-2, 2), (-1, -2), (-1, 2), (0, -2), (0, 2), (1, -2), (1, 2), (2, -2), (2, -1), (2, 0), (2, 1), (2, 2)]

def main():
    #
    H, W = map(int, input().strip().split())
    Ch, Cw = map(lambda x: int(x) - 1 + 2, input().strip().split())
    Dh, Dw = map(lambda x: int(x) - 1 + 2, input().strip().split())
    GRID = []
    ANS = []
    for i in range(H + 4):
        ANS.append([mod for _ in range(W + 4)])

    GRID.append("#" * (W + 4))
    GRID.append("#" * (W + 4))
    for i in range(H):
        S = "##" + input().strip() + "##"
        GRID.append(S)
    GRID.append("#" * (W + 4))
    GRID.append("#" * (W + 4))

    # eprint('GRID ',end=':\n')
    # pprint.pprint(GRID)
    # eprint('ANS ',end=':\n')
    # pprint.pprint(ANS)

    #
    PQ = pq()
    PQ.put((0, Ch, Cw))
    while not(PQ.empty()):
        distance, Uh, Uw = PQ.get()
        distance = -distance

        # ANS[Uh][Uw] の 「スコア」 の 「更新」
        if distance >= ANS[Uh][Uw]:
            continue
        ANS[Uh][Uw] = distance

        #
        for delta_h, delta_w in delta_u:
            new_distance = distance
            new_Uh = Uh + delta_h
            new_Uw = Uw + delta_w
            if GRID[new_Uh][new_Uw] == "#":    #
                continue
            if new_distance >= ANS[new_Uh][new_Uw]:  # 「新しい距離」 が，今までに記録していたその座標における「古い距離」 よりも大きくなってしまう場合，その新しい地点はキューに追加しない()
                continue
            PQ.put((-new_distance, new_Uh, new_Uw))

        for delta_h, delta_w in delta2_u:
            new_distance = distance + 1
            new_Uh = Uh + delta_h
            new_Uw = Uw + delta_w
            if GRID[new_Uh][new_Uw] == "#":    #
                continue
            if new_distance >= ANS[new_Uh][new_Uw]:  # 「新しい距離」 が，今までに記録していたその座標における「古い距離」 よりも大きくなってしまう場合，その新しい地点はキューに追加しない()
                continue
            PQ.put((-new_distance, new_Uh, new_Uw))

    if ANS[Dh][Dw] != sys.maxsize:
        print(ANS[Dh][Dw])
    else:
        print(-1)

if __name__ == '__main__':
    main()


from __future__ import print_function

from functools import reduce
from operator import mul
from collections import Counter
from collections import deque
from itertools import accumulate
from queue import Queue
from queue import PriorityQueue as pq
from heapq import heapreplace
from heapq import heapify
from heapq import heappushpop
from heapq import heappop
from heapq import heappush
import heapq
import time
import random
import bisect
import itertools
import collections
from fractions import Fraction
import fractions
import string
import math
import operator
import functools
import copy
import array
import re
import sys
sys.setrecursionlimit(500000)

import pprint

input = sys.stdin.readline

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return

# from fractions import gcd
# from math import gcd

# def lcm(n, m):
#     return int(n * m / gcd(n, m))

# def coprimize(p, q):
#     common = gcd(p, q)
#     return (p // common, q // common)

# def find_gcd(list_l):
#     x = reduce(gcd, list_l)
#     return x

def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom

mod = 1000000007

def combinations_count_mod(n, r):
    r = min(r, n - r)
    numer = reduce(lambda x, y: x * y % mod, range(n, n - r, -1), 1)
    denom = pow(reduce(lambda x, y: x * y % mod, range(1, r + 1), 1), mod - 2, mod)
    return numer * denom % mod

def solve():
    pass

delta_u = [(1, 0), (0, 1), (-1, 0), (0, -1)]
# [(u, v) for u in range(-2, 3) for v in range(-2, 3)]
delta2_u = [(-1, -1), (-1, 1), (1, -1), (1, 1), (-2, -2), (-2, -1), (-2, 0), (-2, 1), (-2, 2), (-1, -2), (-1, 2), (0, -2), (0, 2), (1, -2), (1, 2), (2, -2), (2, -1), (2, 0), (2, 1), (2, 2)]

def main():
    #
    H, W = map(int, input().strip().split())
    Ch, Cw = map(lambda x: int(x) -1 + 2, input().strip().split())
    Dh, Dw = map(lambda x: int(x) -1 + 2, input().strip().split())
    GRID = []
    ANS = []
    for i in range(H + 4):
        ANS.append([sys.maxsize for _ in range(W+4)])

    GRID.append("#" * (W+4))
    GRID.append("#" * (W+4))
    for i in range(H):
        S = "##" + input().strip() + "##"
        GRID.append(S)
    GRID.append("#" * (W+4))
    GRID.append("#" * (W+4))

    # eprint('GRID ',end=':\n')
    # pprint.pprint(GRID)
    # eprint('ANS ',end=':\n')
    # pprint.pprint(ANS)

    #
    PQ = pq()
    PQ.put((0, Ch, Cw))
    while not(PQ.empty()):
        distance, Uh, Uw = PQ.get()
        distance = -distance

        # ANS[Uh][Uw] の 「スコア」 の 「更新」
        if distance >= ANS[Uh][Uw]:
            continue
        ANS[Uh][Uw] = distance

        #
        for delta_h, delta_w in delta_u:
            new_distance = distance
            new_Uh = Uh + delta_h
            new_Uw = Uw + delta_w
            if GRID[new_Uh][new_Uw] == "#":    #
                continue
            if new_distance >= ANS[new_Uh][new_Uw]:  # 「新しい距離」 が，今までに記録していたその座標における「古い距離」 よりも大きくなってしまう場合，その新しい地点はキューに追加しない()
                continue
            PQ.put((-new_distance, new_Uh, new_Uw))

        for delta_h, delta_w in delta2_u:
            new_distance = distance + 1
            new_Uh = Uh + delta_h
            new_Uw = Uw + delta_w
            if GRID[new_Uh][new_Uw] == "#":    #
                continue
            if new_distance >= ANS[new_Uh][new_Uw]:  # 「新しい距離」 が，今までに記録していたその座標における「古い距離」 よりも大きくなってしまう場合，その新しい地点はキューに追加しない()
                continue
            PQ.put((-new_distance, new_Uh, new_Uw))

    if ANS[Dh][Dw] != sys.maxsize:
        print(ANS[Dh][Dw])
    else:
        print(-1)

if __name__ == '__main__':
    main()


import numpy as np
H , W  = (int(d) for d in input().split())
Ch, Cw = (int(d)-1 for d in input().split())
Dh, Dw = (int(d)-1 for d in input().split())

M = np.array(
    [
        [True if d == "." else False for d in input()] for j in range(H)
    ]
)

move1 = [[-1,0], [1,0], [0,-1], [0,1]]
move2 = [
    [-2,-2], [-2,-1], [-2,0], [-2,1], [-2,2],
    [-1,-2], [-1,-1], [-1,1], [-1,2],
    [0,-2], [0,2],
    [1,-2], [1,-1], [1,1], [1,2],
    [2,-2], [2,-1], [2,0], [2,1], [2,2],
]

seen = set()
dist = np.ones([H, W], dtype=int) * 1000000
Q = [(Ch, Cw)]
seen.update(Q)
dist[Ch, Cw] = 0

while len(Q) > 0:
    P = Q.pop()
    for i in range(4):
        a = P[0]+move1[i][0]
        b = P[1]+move1[i][1]
        if a >= 0 and a < H and b >=0 and b < W and M[a, b]:
            dist[a, b] = min(dist[P], dist[a,b])
            if not (a, b) in seen:
                seen.update([(a, b)])
                Q.append((a, b))
    for i in range(20):
        a = P[0]+move2[i][0]
        b = P[1]+move2[i][1]
        if a >= 0 and a < H and b >=0 and b < W and M[a, b]:
            dist[a, b] = min(dist[P] + 1, dist[a, b])
            if not (a, b) in seen:
                seen.update([(a, b)])
                Q.append((a, b))

D = dist[Dh, Dw]
if D == 1000000:
    print(-1)
else:
    print(D)