import java.util.Scanner;
import java.io.BufferedReader;
import java.io.*;
import java.util.StringTokenizer;

public class One_Based_Arithmetic {

        static MyScanner sc;
        static MyWriter pw;
        static String filePathWin="d:\\lmo.in";
        static String filePathLinux="/media/luismo/Trabajo/lmo.in";
        public static void main(String[] args) throws IOException {
            sc = new MyScanner(System.in);

            // sc = new MyScanner(new FileReader(filePathWin));
            // sc = new MyScanner(new FileReader(filePathLinux));

            pw = new MyWriter(System.out);

            while(sc.canRead())
                SolveSingleProblem();

            pw.close();
        }

        public static void SolveSingleProblem() throws IOException{

            long n = sc.nextLong();

            long dig = (long)Math.log10(n) + 1;

            long mirr = n;

            String s = "";
            for(int i =0; i < dig + 1; i++)
                s+="1";

            long k = Long.parseLong(s);

            long answ1 = best(n, k);

            pw.println(answ1);
        }

        static long best(long n, long k){

            if(k == 1) return n;

            int cumul = 0;
            int digits = (int)Math.log10(k) + 1;

            if(n == k){
                return digits;
            }

            if(k < n){
                return digits + best(n - k , k);
            }

            long left = digits + best( k - n, k / 10);

            long right = best(n, k / 10);

            return min(left, right);
        }

        static long min(long a, long b){
            return (a < b)? a: b;
        }

    }

    class MyScanner{
        BufferedReader br;
        StringTokenizer stk;
        public MyScanner(InputStream stream){
            this.br = new BufferedReader(new InputStreamReader(stream),72357);
            this.stk = new StringTokenizer("");
        }
        public MyScanner(FileReader fr){
            this.br = new BufferedReader(fr);
            this.stk = new StringTokenizer("");
        }
        public String next() throws IOException {
            while(!stk.hasMoreElements()){
                String line = br.readLine();
                if(line == null)
                    return null;
                stk = new StringTokenizer(line);
            }
            return stk.nextToken();
        }
        public int nextInt()throws IOException{
            return Integer.parseInt(next());
        }

        public long nextLong()throws IOException{
            return Long.parseLong(next());
        }

        public double nextDouble()throws IOException{
            return Double.parseDouble(next());
        }

        public boolean canRead() throws IOException{
            return br.ready();
        }
    }

    class MyWriter{
        PrintWriter pw;
        public MyWriter(OutputStream out){
            this.pw = new PrintWriter(out);
        }
        public void print(Object obj){
            pw.print(obj.toString());
        }
        public void println(Object obj){
            pw.println(obj.toString());
        }
        public void close() {
            pw.close();
        }
}


import java.util.Scanner;

public class oneBased {
    static int DP[];
    static int size = Integer.MAX_VALUE / 100;

    public static int rec(long x) {

        if (x == 0)
            return 0;
        if (x <= size && DP[((int) x) - 1] != 0)
            return DP[((int) x) - 1];
        int res = 0;
        long counter = x;
        int numOfBits = 0;
        String onesString = "";
        while (counter > 0) {
            onesString += "1";
            counter /= 10;
            numOfBits++;
        }

        long ones = Long.parseLong(onesString);
        long ones2 = Long.parseLong((onesString + "1"));
        long reminder = (ones > x) ? ones - x : x - ones;
        long reminder2 = ones2 - x;
        int res1 = rec(reminder);
        res1 += numOfBits;
        int res2 = Integer.MAX_VALUE;
        if (reminder2 < x) {
            res2 = rec(reminder2);
            res2 += numOfBits + 1;
        }
        res = Math.min(res1, res2);
        if (x <= size)
            DP[((int) x) - 1] = res;
        return res;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long x = sc.nextLong();
        DP = new int[size];
        // System.out.println(rec(x));
        long x1 = Long.parseLong("81924761239462");
        long x2 = Long.parseLong("11111111111111");
        System.out.println(rec(x));

    }
    // 81924761239462

}


import java.util.Scanner;
public class OBADef
{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        long num = scan.nextLong();
        System.out.println(""+prog(num,(int)(Math.log10(Math.abs(num)))+1));
    }
    public static long genUnos(long n){
        return (long)(Math.pow(10,n)-1)/9;
    }
    public static long prog(long n, int tam){
        long unos=genUnos(1+tam);
        long veces=n/unos*(1+tam);
        n%=unos;
        if(n==0) return veces;
        return veces+Math.min((1+tam)+prog(unos-n,tam-1),prog(n,tam-1));
        }
}


import java.io.BufferedReader;
    import java.io.*;
    import java.util.StringTokenizer;

    /**
     * Author: Luis Manuel Díaz Barón
     * Problem:
     * Online Judge:
     * Idea:
     * Fecha: 20/02/2013
     */

    public class Main {

        static MyScanner sc;
        static MyWriter pw;
        static String filePathWin="d:\\lmo.in";
        static String filePathLinux="/media/luismo/Trabajo/lmo.in";
        public static void main(String[] args) throws IOException {
            sc = new MyScanner(System.in);

            // sc = new MyScanner(new FileReader(filePathWin));
            // sc = new MyScanner(new FileReader(filePathLinux));

            pw = new MyWriter(System.out);

            while(sc.canRead())
                SolveSingleProblem();

            pw.close();
        }

        public static void SolveSingleProblem() throws IOException{

            long n = sc.nextLong();

            long dig = (long)Math.log10(n) + 1;

            long mirr = n;

            String s = "";
            for(int i =0; i < dig + 1; i++)
                s+="1";

            long k = Long.parseLong(s);

            long answ1 = best(n, k);

            pw.println(answ1);
        }

        static long best(long n, long k){

            if(k == 1) return n;

            int cumul = 0;
            int digits = (int)Math.log10(k) + 1;

            if(n == k){
                return digits;
            }

            if(k < n){
                return digits + best(n - k , k);
            }

            long left = digits + best( k - n, k / 10);

            long right = best(n, k / 10);

            return min(left, right);
        }

        static long min(long a, long b){
            return (a < b)? a: b;
        }

    }

    class MyScanner{
        BufferedReader br;
        StringTokenizer stk;
        public MyScanner(InputStream stream){
            this.br = new BufferedReader(new InputStreamReader(stream),72357);
            this.stk = new StringTokenizer("");
        }
        public MyScanner(FileReader fr){
            this.br = new BufferedReader(fr);
            this.stk = new StringTokenizer("");
        }
        public String next() throws IOException {
            while(!stk.hasMoreElements()){
                String line = br.readLine();
                if(line == null)
                    return null;
                stk = new StringTokenizer(line);
            }
            return stk.nextToken();
        }
        public int nextInt()throws IOException{
            return Integer.parseInt(next());
        }

        public long nextLong()throws IOException{
            return Long.parseLong(next());
        }

        public double nextDouble()throws IOException{
            return Double.parseDouble(next());
        }

        public boolean canRead() throws IOException{
            return br.ready();
        }
    }

    class MyWriter{
        PrintWriter pw;
        public MyWriter(OutputStream out){
            this.pw = new PrintWriter(out);
        }
        public void print(Object obj){
            pw.print(obj.toString());
        }
        public void println(Object obj){
            pw.println(obj.toString());
        }
        public void close() {
            pw.close();
        }
    }


import java.util.LinkedList;
import java.util.Scanner;

public class T440C {
	private long[] N = {
			1,
			11,
			111,
			1111,
			11111,
			111111,
			1111111,
			11111111,
			111111111,
			1111111111,
			11111111111L,
			111111111111L,
			1111111111111L,
			11111111111111L,
			111111111111111L,
			1111111111111111L
		};

	public long solve(long n) {
		long ans = Long.MAX_VALUE;
		LinkedList<long[]> l = new LinkedList<long[]>();
		l.add(new long[] {n, 0});
		long[] e;
		while (!l.isEmpty()) {
			e = l.getFirst();
			l.removeFirst();

			if (e[0] == 0 || e[1] > ans) {
				ans = Math.min(ans, e[1]);
				continue;
			}
			for (int i = N.length - 1; i >= 0; i --) {
				if (e[0] >= N[i]) {
					long x,y;

					y = e[1] + (e[0] / N[i]) *(i + 1);
					x = e[0] % N[i];
					l.add(new long[] {x, y});

					if (i < N.length - 1) {
						y = e[1] + (i + 1) + 1;
						x = N[i + 1] - e[0];
						l.add(new long[] {x, y});

					}
					break;
				}
			}
		}
		return ans;
	}
	public static void main(String[] args) {
		T440C t = new T440C();

		//long n = 973546235465729L;
		Scanner in = new Scanner(System.in);
		long n = in.nextLong();

		System.out.println(t.solve(n));
	}

}


import java.util.Arrays;
import java.util.Scanner;

public class C {
    static int inf = (int) 1e6;
    static int[][][][] DP;
    static String number;

    public static int get(int index, int pos, int neg, int carry) {
        int truCarry = carry - 50;
        if (index == 17) {
            if (pos + neg + truCarry == 0) {
                return 0;
            } else {
                return inf;
            }
        }
        if (DP[index][pos][neg][carry] != -1)
            return DP[index][pos][neg][carry];
        int res = inf;
        for (int p = 0; p <= Math.min(15, pos); p++)
            for (int n = 0; n <= Math.min(15, neg); n++) {
                int sum = pos - neg + truCarry;
                int currentBit = (sum % 10 + 10) % 10;
                int nextCarry = sum > 0 ? (sum / 10) : ((sum - 9) / 10);
                if (currentBit != number.charAt(index) - '0')
                    continue;
                res = Math.min(res,
                        get(index + 1, pos - p, neg - n, nextCarry + 50)
                                + (p + n) * (index + 1));
            }
        return DP[index][pos][neg][carry] = res;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        int size = 50;
        DP = new int[20][size][size][100];
        for (int i = 0; i < 20; i++)
            for (int j = 0; j < size; j++)
                for (int k = 0; k < size; k++)
                    Arrays.fill(DP[i][j][k], -1);
        number = "" + n;
        while (number.length() < 17)
            number = "0" + number;
        number = new StringBuffer(number).reverse().toString();
        int res = inf;
        for (int pos = 0; pos < size; pos++)
            for (int neg = 0; neg < size; neg++)
                res = Math.min(res, get(0, pos, neg, 50));
        System.out.println(res);
    }
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
import java.util.TreeSet;

/**
 *
 *
 * 10 5 8 1 10 3 6 2 9 7 4 4 2 6 3 1 9 10 5 8 7
 *
 * @author pttrung
 */
public class C {

    //   public static long x, y, gcd;
    public static int Mod = 1000000007;
    public static PrintWriter out;

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner();
        out = new PrintWriter(System.out);
        //   System.out.println(Integer.MAX_VALUE);
        //PrintWriter out = new PrintWriter(new FileOutputStream(new File("output.txt")));
        long n = in.nextLong();
        int result = cal(n, -1);

        out.println(result);

        out.close();
    }

    public static int cal(long val, long last) {
        if(val == 0){
            return 0;
        }
        long start = 1;
        int c = 1;
        while (start < val) {
            start *= 10;
            start++;
            c++;
        }

        if (start > val ) {

            long a = start / 10;

            int result = (int) ((c - 1) + cal(val - a, start));
            if (last != start) {
                result = Math.min(result, c + cal(start - val, start));
            }
            return result;
        } else {
            return c;
        }
    }

    public static long pow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val;
        } else {
            return val * val * a;
        }
    }

    public static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(Point o) {
            if (x != o.x) {
                return x - o.x;
            } else {
                return y - o.y;
            }
        }
    }
//    public static void extendEuclid(long a, long b) {
//        if (b == 0) {
//            x = 1;
//            y = 0;
//            gcd = a;
//            return;
//        }
//        extendEuclid(b, a % b);
//        long x1 = y;
//        long y1 = x - (a / b) * y;
//        x = x1;
//        y = y1;
//
//    }

    public static class FT {

        int[] data;

        FT(int n) {
            data = new int[n];
        }

        public void update(int index, int value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public int get(int index) {
            int result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.*;

public class Main {
	public static void main(String arg[])throws Exception{
		BufferedReader bff = new BufferedReader(new InputStreamReader(System.in));
		long n = Long.parseLong(bff.readLine());
		System.out.println(ones(n));
	}
	private static int digs(long n){
		return (int) Math.log10(n) + 1;
	}
	private static long fillOne(int n){
		long res = 1;
		while(n-- > 1)
			res = res * 10 + 1;
		return res;
	}

	private static long ones (long n){
		if(n <= 6) return n;
		int dig = digs(n);
		long aux = fillOne(dig), one = aux, diff = n;
		int c = 0;
		//System.out.println(aux);
		while(aux < n){
			c++;
			diff = n - aux;
			aux += one;
		}
		//System.out.println(diff + " " + aux);
		long res;
		if(c > 0)
			res = Math.min(c*dig + ones(diff), ++c * dig + ones(aux - n));
		else
			res = ++c * dig + ones(aux - n);
		aux = fillOne(dig + 1);
		if(aux - n < n)
			res = Math.min(res, dig + 1 + ones(aux - n));
		return res;
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class OneBasedArithmetic {
    public static void main(String[] args) {
        FastReader sc = new FastReader();
        long n = sc.nextLong();
        long[] ones = new long[17];
        for(int i = 1; i < 17; ++i){
            ones[i] = 10 * ones[i - 1] + 1;
        }

        //System.out.println(Arrays.toString(ones));
        long ans = dfs(ones, n, 16);
        System.out.println(ans);
    }

    private static long dfs(long[] ones, long n, int idx){

        //System.out.println(n +", " + idx);
        long quot = n / ones[idx];
        n %= ones[idx];
        long onesUsedHere = quot * idx;
        //System.out.println("q : " + quot +", n : " + n);
        if(n == 0) return onesUsedHere;
        else
            return onesUsedHere + Math.min(dfs(ones, n, idx - 1),
                    idx + dfs(ones, ones[idx] - n, idx - 1));
    }
    private static class FastReader {
        private final BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        int[] readArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; ++i)
                arr[i] = nextInt();

            return arr;
        }

        List<Integer> readList(int n) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < n; ++i)
                list.add(nextInt());
            return list;
        }

        long[] readLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; ++i)
                arr[i] = nextLong();

            return arr;
        }

        double[] readDoubleArray(int n) {
            double[] arr = new double[n];
            for (int i = 0; i < n; ++i)
                arr[i] = nextDouble();
            return arr;
        }
    }
}


import java.io.*;
import java.math.*;
import java.util.*;

public class Main {

	static PrintWriter out;

	static double EPS = 1e-9;
	static int INF = (int) 1e9;
	static long LINF = (long) 1e18;
	static int MOD = (int) 1e9 + 7;
	static double PI = Math.acos(-1);

	static int go(long n) {
		if (n == 0) {
			return 0;
		}
		long k = 1;
		int cnt = 1;
		while (k * 10 + 1 < n) {
			k = k * 10 + 1;
			cnt++;
		}
		return (int) Math.min(go(n % k) + n / k * cnt, go((k * 10 + 1 - n) % k) + (cnt + 1) +  (k * 10 + 1 - n) / k * cnt);
	}

	static void solve() {
		long n = Input.nextLong();
		out.println(go(n));
	}

	public static void main(String[] args) {
		out = new PrintWriter(System.out);
//		long stime = System.currentTimeMillis();
		solve();
//		out.println("\nTime elapsed: " + (System.currentTimeMillis() - stime) + "ms");
		out.close();
	}

	static class SegmentTree {
		int maxn = 100010;
		long[] st = new long[4 * maxn];
		void update(int node, int i, int L, int R, long val) {
			if (i < L || i > R) return;
			if (L == R) {st[node] += val; return;}
			update(node << 1, i, L, (L + R) >> 1, val);
			update((node << 1) + 1, i, ((L + R) >> 1) + 1, R, val);
			st[node] = st[node << 1] + st[(node << 1) + 1];
		}
		long query(int node, int l, int r, int L, int R) {
			if (l > R || r < L) return 0;
			if (l <= L && r >= R) return st[node];
			return query(node << 1, l, r, L, (L + R) >> 1) + query((node << 1) + 1, l, r, ((L + R) >> 1) + 1, R);
		}
	}

	static class Matrix {
		int maxn = 2;
		int[][] x = new int[maxn][maxn];
		Matrix mul(Matrix A) {
			Matrix res = new Matrix();
			for (int i = 0; i < maxn; i++) {
				for (int k = 0; k < maxn; k++) {
					for (int j = 0; j < maxn; j++) {
						res.x[i][j] = (int) ((res.x[i][j] + (long) x[i][k] * A.x[k][j]) % MOD);
					}
				}
			}
			return res;
		}
		Matrix pow(long k) {
			Matrix res = this, T = this; k--;
			while (k > 0) {
				if ((k & 1) > 0) {
					res = res.mul(T);
				}
				T = T.mul(T); k >>= 1;
			}
			return res;
		}
	}

	static class Pair implements Comparable<Pair> {
		long fi, se;
		Pair(long fi, long se) {
			this.fi = fi;
			this.se = se;
		}
		public int compareTo(Pair oth) {
			if (fi > oth.fi) return +1;
			if (fi < oth.fi) return -1;
			if (se > oth.se) return +1;
			if (se < oth.se) return -1;
			return 0;
		}
	}

	static long gcd(long a, long b) {
		long r;
		while (b != 0) {
			r = a % b;
			a = b;
			b = r;
		}
		return a;
	}

	static long lcm(long a, long b) {
		return a / gcd(a, b) * b;
	}

	static long fpow(long n, long k, int p) {
		long r = 1;
		for (; k > 0; k >>= 1) {
			if (k % 2 == 1) {
				r = r * n % p;
			}
			n = n * n % p;
		}
		return r;
	}

	static BigInteger FloorOfNthRoot(BigInteger x, int n) {
	    int sign = x.signum();
	    if (n <= 0 || sign < 0) {
	        throw new IllegalArgumentException();
	    }
	    if (sign == 0) {
	        return BigInteger.ZERO;
	    }
	    if (n == 1) {
	        return x;
	    }
	    BigInteger a;
	    BigInteger bigN = BigInteger.valueOf(n);
	    BigInteger bigNMinusOne = BigInteger.valueOf(n - 1);
	    BigInteger b = BigInteger.ZERO.setBit(1 + x.bitLength() / n);
	    do {
	        a = b;
	        b = a.multiply(bigNMinusOne).add(x.divide(a.pow(n - 1))).divide(bigN);
	    }
	    while (b.compareTo(a) == -1);
	    return a;
	}

	static BigDecimal sqrt(BigDecimal A, int SCALE) {
	    BigDecimal x0 = new BigDecimal("0");
	    BigDecimal x1 = new BigDecimal(Math.sqrt(A.doubleValue()));
	    while (!x0.equals(x1)) {
	        x0 = x1;
	        x1 = A.divide(x0, SCALE, BigDecimal.ROUND_HALF_UP);
	        x1 = x1.add(x0);
	        x1 = x1.divide(BigDecimal.valueOf(2), SCALE, BigDecimal.ROUND_HALF_UP);
	    }
	    return x1;
	}

	static class Input {
		static StringTokenizer token = null;
		static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//		static BufferedReader in;
//		static {
//			try {
//				in = new BufferedReader(new FileReader("in.txt"));
//			} catch (IOException e) {
//			}
//		}
		static int nextInt() {
			return Integer.parseInt(nextString());
		}
		static long nextLong() {
			return Long.parseLong(nextString());
		}
		static double nextDouble() {
			return Double.parseDouble(nextString());
		}
		static String nextString() {
			try {
				while (token == null || !token.hasMoreTokens()) {
					token = new StringTokenizer(in.readLine());
				}
			} catch (IOException e) {
			}
			return token.nextToken();
		}
	}
}


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 *
 * @author sousnake
 */
public class C440_cpy {
    static long arr[];
    public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            long n = Long.parseLong(br.readLine());
            arr = new long[20];
            for(int i=1;i<=16;i++){
                arr[i]=arr[i-1]*10+1;
            }
            System.out.println(fuc(n,16));
    }
    public static long fuc(long n, int d){
        long q =(n/arr[d]*d);
        n %=arr[d];
        if (n==0)
            return q;
        else return q+Math.min(d+fuc(arr[d]-n,d-1),fuc(n,d-1));
    }
}


import java.util.*;

public class candy {
   public static void main (String[] args){
      Scanner sc = new Scanner(System.in);
      int n = sc.nextInt();
      int k = sc.nextInt();
      int[] a = new int[n];
      for (int i = 0; i < n; i++) {
         a[i] = sc.nextInt();
      }
      int day = 0;
      int arya = 0;
      for (int i = 0; i < n; i++) {
         if (a[i] + arya < 8) {
            day++;
            k -= a[i] + arya;
            arya = 0;
         if (k <= 0) {
            System.out.println(day);
            break;
         }

         }
         else if (a[i] + arya >= 8) {
            day++;
            k -= 8;
            arya += a[i] - 8;
            if (k <= 0) {
               System.out.println(day);
               break;
              }

         }
      }
      if (k > 0) {
         System.out.println(-1);
      }
   }
}


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.Scanner;

/**
 *
 * @author Lotus
 */
public class B {

    public static void main(String[]args)
    {
        Scanner input = new Scanner (System.in);
        String t  = input.next();
        String ices = input.next();
        int [] counter = new int[9];

            for(int j=0; j<ices.length();j++)
            {

                    if(ices.charAt(j)=='9')
                        counter[6]++;
                    else if(ices.charAt(j)=='5' )
                    {
                         counter[2]++;

                    }
                     else
                    counter[ices.charAt(j)-48]++;

            }
        int count=0;
        int n;
        boolean m=false;
        while(m!=true)
        {
         for(int i=0; i<t.length();i++)
            {

                     if(t.charAt(i)=='9')
                         n=6;

                    else if(t.charAt(i)=='5' )
                    {
                        n=2;

                    }
                     else
                   n=t.charAt(i)-48;

                     counter[n]--;
                   if( counter[n]<0)
                   {
                       m=true;
                       break;

                   }
            }
        if(!m)
         count++;

            }

        System.out.println(count);

    }

}


import java.io.*;
import java.util.*;
public class Main {
    public static void main(String[] args) throws IOException {

        Scanner sc = new Scanner(System.in);
        int n, k;
        n = sc.nextInt();
        k = sc.nextInt();
        String buff_s = sc.next();
        char[] s = buff_s.toCharArray();

        boolean ans = false;
        boolean cur = true;

        int cnt = 0;
        for (int i = 0; i < n && cur; i++) {

            if (s[i] == 'N')
                cnt++;
            else
                cnt = 0;

            if (cnt > k)
                cur = false;

        }

        for (int is = 0; is <= n - k && cur && !ans; is++) {

            for (int j = is; j < is + k && cur; j++) {
                if (s[j] == 'Y')
                    cur = false;
            }

            if (cur) {

                if (is > 0 && s[is - 1] == 'N')
                    cur = false;

                if (is + k < n && s[is + k] == 'N')
                    cur = false;

            }

            if (cur) {

                ans = true;

            }

            cur = true;

        }

        if (ans) {

            System.out.println("YES");

        } else {

            System.out.println("NO");

        }

    }

}


import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.io.*;
import java.math.BigInteger;
import static java.math.BigInteger.*;
import java.util.*;
public class C{
	int n;
	int[][]min;
	int[][]max;
	int[][]active;
	int[]pFlow;
	int inf=Integer.MAX_VALUE/100;
	int[]res;
	int allCost=0;
	void solve()throws Exception
	{

		n=nextInt();
		min=new int[n][n];
		max=new int[n][n];
		active=new int[n][n];
		int sum=0;
		for(int step=1;step<=n*(n-1)/2;step++)
		{
			int a=nextInt()-1;
			int b=nextInt()-1;
			min[a][b]=nextInt();
			max[a][b]=nextInt();
			active[a][b]=nextInt();
			sum+=max[a][b];
		}
		res=new int[]{inf,-inf};
		sum++;
		pFlow=new int[n];
		rec(0,1);
		if(res[0]==inf)
			res=new int[]{-1,-1};
		System.out.println(res[0]+" "+res[1]);
	}

	private void rec(int a, int b) {
		if(res[0]<pFlow[0])
			return;
		if(a==n-1)
		{
			if(pFlow[0]<res[0] || (res[0]==pFlow[0] && allCost>res[1]))
			{
				res[0]=pFlow[0];
				res[1]=allCost;

			}
			return ;
		}
		if(b==n)
		{
			if(a!=0 && pFlow[a]!=0)
				return;
			rec(a+1,a+2);
		}
		else
		{
			for(int x=min[a][b];x<=max[a][b];x++)
			{
				int curCost=x*x+(x>0?active[a][b]:0);
				pFlow[a]+=x;
				pFlow[b]-=x;
				allCost+=curCost;
				rec(a,b+1);
				allCost-=curCost;
				pFlow[a]-=x;
				pFlow[b]+=x;
			}
		}

	}

	BufferedReader reader;
	PrintWriter writer;
	StringTokenizer stk;
	void run()throws Exception
	{
		reader=new BufferedReader(new InputStreamReader(System.in));
		stk=null;
		writer=new PrintWriter(System.out);
		solve();
		reader.close();
		writer.close();
	}
	int nextInt()throws Exception
	{
		return Integer.parseInt(nextToken());
	}
	long nextLong()throws Exception
	{
		return Long.parseLong(nextToken());
	}
	double nextDouble()throws Exception
	{
		return Double.parseDouble(nextToken());
	}
	String nextString()throws Exception
	{
		return nextToken();
	}
	String nextLine()throws Exception
	{
		return reader.readLine();
	}
	String nextToken()throws Exception
	{
		if(stk==null || !stk.hasMoreTokens())
		{
			stk=new StringTokenizer(nextLine());
			return nextToken();
		}
		return stk.nextToken();
	}

	public static void main(String[]args) throws Exception
	{
		new C().run();

	}

}


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        int LocPar1, LocPar2;

        a *= 2;
        b *= 2;

        LocPar1 = x1;
        LocPar2 = y1;
        x1 = LocPar1 + LocPar2;
        y1 = LocPar2 - LocPar1;

        LocPar1 = x2;
        LocPar2 = y2;
        x2 = LocPar1 + LocPar2;
        y2 = LocPar2 - LocPar1;

        if (x1>0)
            x1 = x1/a+1;
        else
            x1 = x1/a;
        if (x2>0)
            x2 = x2/a+1;
        else
            x2 = x2/a;
        if (y1>0)
            y1 = y1/b+1;
        else
            y1 = y1/b;
        if (y2>0)
            y2 = y2/b+1;
        else
            y2 = y2/b;
        System.out.println(Math.max(Math.abs((y2-y1)),Math.abs((x2-x1))));
    }
}


import java.io.*;
import java.util.*;

public class codeforces {
    static class pair {
        int x;
        int y;

        public pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    public static long sqrt(long x) {
        long s = 0, e = x, root = 0;
        while (s <= e) {
            long mid = (s + e) / 2;
            if (mid * mid == x)
                return mid;
            if (mid * mid < x) {
                root = mid;
                s = mid + 1;
            } else
                e = mid - 1;
        }
        return root;
    }

    public static long power(int a, int b) {
        if (a == 0 || b == 0)
            return 1;
        long ans = power(a, b / 2);
        ans *= ans;
        if (b % 2 == 1)
            ans *= a;
        return ans;
    }

    public static boolean isSubsequence(String a, String b){
        int m=a.length(),n=b.length(),i=0,j=0;
        while(i<m && j<n){
            if(a.charAt(i)==b.charAt(j)){
                i++;
            }
            j++;
        }
        return i==m;
    }

    public static boolean isprime(long x) {
        if (x == 1)
            return false;
        if (x < 4)
            return true;
        int root = (int) Math.sqrt(x);
        for (int i = 2; i <= root; i++) {
            if (x % i == 0)
                return false;
        }
        return true;
    }

    public static long max(long a, long b) {
        return Math.max(a, b);
    }

    public static long min(long a, long b) {
        return Math.min(a, b);
    }

    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder str = new StringBuilder();
        PrintWriter out = new PrintWriter(System.out);
        // int t = Integer.parseInt(br.readLine());
        ArrayList<Long> a=new ArrayList<>();
        String[] l=br.readLine().split(" ");
        long n=Long.parseLong(l[0]);
        int k=Integer.parseInt(l[1]);
        long root=(long) Math.sqrt(n);
        int c=0;
        for(long i=1;i<=root;i++){
            if(n%i==0){
                c++;
                a.add(i);
                if(c==k){
                    out.println(i);
                    break;
                }
            }
        }
        // for(int x:a)
        // out.println(x);
        l:
        if(k>c){
            boolean b=false;
            if(root*root==n)
            b=true;
            if(b && 2*c-1<k){
                out.println("-1");
                break l;
            }
            else
            if(!b && 2*c<k){
                out.println("-1");
                break l;
            }
            else
            if(b){
                str.append(n/a.get(c-(k-c+1))).append("\n");
                out.print(str);
                break l;
            }
            else{
                str.append(n/a.get(c-(k-c))).append("\n");
                out.print(str);
                break l;
            }
        }
        // if(k>c)
        // out.print("-1");
        out.close();
    }
}


import java.io.*;
import java.util.*;

public class Main implements Runnable {

	public void _main() throws IOException {
		int x = nextInt();
		int y = nextInt();
		int z = nextInt();
		int[] a = new int[]{x, y, z};
		Arrays.sort(a);
		x = a[0];
		y = a[1];
		z = a[2];
		int k = nextInt();
		if (k > x + y + z - 3)
			k = x + y + z - 3;
		int b = k / 3;
		long dx = 0, dy = 0, dz = 0;
		if (b > x - 1) {
			dx = x - 1;
			k -= dx;
			b = k / 2;
			if (b > y - 1) {
				dy = y - 1;
				k -= dy;
				dz = Math.min(k, z - 1);
			}
			else {
				dy = dz = b;
				k -= 2 * b;
				if (k > 0) {
					--k;
					++dz;
				}
			}
		}
		else {
			dx = dy = dz = b;
			k -= 3 * b;
			if (k > 0) {
				--k;
				++dz;
			}
			if (k > 0) {
				--k;
				++dy;
			}
		}
		dx = Math.min(dx, x - 1);
		dy = Math.min(dy, y - 1);
		dz = Math.min(dz, z - 1);
		out.println((dx + 1) * (dy + 1) * (dz + 1));
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;

	private String next() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String rl = in.readLine();
			if (rl == null)
				return null;
			st = new StringTokenizer(rl);
		}
		return st.nextToken();
	}

	private int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	private long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	private double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	public static void main(String[] args) {
		Locale.setDefault(Locale.UK);
		new Thread(new Main()).start();
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);

			_main();

			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(202);
		}
	}

}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.fill;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;

public class Main {
	public static void main(String[] args) throws IOException {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					try {
						if (new File("input.txt").exists())
							System.setIn(new FileInputStream("input.txt"));
					} catch (SecurityException e) {}
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, "1", 1L << 24).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int OFFSET = 500;

	int N;
	int D;
	int[][] dx;
	int[][] dy;

	int[][] mem;

	int UNKNOWN = 0;
	int WIN = 1;
	int LOOSE = 2;

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		N = nextInt();
		int d = nextInt(); D = d * d;

		dx = new int [2][N];
		dy = new int [2][N];

		for (int i = 0; i < N; i++) {
			dy[1][i] = dx[0][i] = nextInt();
			dx[1][i] = dy[0][i] = nextInt();
		}

		mem = new int [2 * OFFSET + 1][2 * OFFSET + 1];
		out.println(rec(x, y, 0) == WIN ? "Anton" : "Dasha");

		out.close();
	}

	int rec(int x, int y, int rot) {
		if (x * x + y * y > D) return WIN;
		int mem = mem(x, y);
		if (mem != UNKNOWN) return mem;
		int ret = LOOSE;
		for (int dir = 0; dir < N; dir++) {
			int nx = x + dx[rot][dir];
			int ny = y + dy[rot][dir];
			int res = rec(nx, ny, rot);
			if (res == LOOSE) {
				ret = WIN;
				break;
			}
		}
		return remember(x, y, ret);
	}

	int remember(int x, int y, int val) {
		return mem[x + OFFSET][y + OFFSET] = val;
	}

	int mem(int x, int y) {
		return mem[x + OFFSET][y + OFFSET];
	}

	/***************************************************************
	 * Input
	 **************************************************************/
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class MainE {

    private FastScanner in;
    private PrintWriter out;

    long MOD = 998244353L;

    long[] gcd_ex(long a, long b) {
        if (a == 0) {
            return new long[]{0, 1};
        }
        long[] res = gcd_ex(b % a, a);
        long t = res[0];
        res[0] = res[1] - (b / a) * res[0];
        res[1] = t;
        return res;
    }

    long reverse(long a) {
        return (gcd_ex(a, MOD)[0] + 100 * MOD) % MOD;
    }

    long powMod(long a, long b) {
        long res = 1;
        long mul = a;
        while (b > 0) {
            if ((b & 1) > 0) {
                res = (res * mul) % MOD;
            }
            mul = (mul * mul) % MOD;
            b /= 2;
        }
        return res;
    }

    public void solve() {
        long N = in.nextInt();
        long[] combs = new long[(int)(N + 1)];
        combs[0] = 1;
        for (int i = 1; i <= N; i++) {
            long t = combs[i - 1];
            t = (t * (N - i + 1)) % MOD;
            t = (t * reverse(i)) % MOD;
            combs[i] = t;
        }
        long res = 0;
        long p1 = 1;
        long p2 = 1;
        long R = powMod(reverse(3), N);
        for (int i = 1; i <= N; i++) {
            p1 = (p1 * R) % MOD;
            p2 = (p2 * 3) % MOD;
            long t = combs[i] * p1 % MOD;
            t = (t * p2) % MOD;
            if ((i & 1) > 0) {
                res += 2 * t;
            } else {
                res = (res + 2 * MOD - 2 * t) % MOD;
            }
            res %= MOD;
        }
        res = res * powMod(3, N * N) % MOD;
        long i3 = 1;
        for (int i = 0; i < N; i++){
            long mi3 = (MOD - i3) % MOD;
            i3 = (i3 * 3) % MOD;
            long t = combs[i] * ((MOD + powMod(1 + mi3, N) - powMod(mi3, N)) % MOD) % MOD;
            if ((i & 1) > 0) {
                res += 3 * t;
            } else {
                res = (res + 3 * MOD - 3 * t) % MOD;
            }
            res %= MOD;
        }
        System.out.println(res);
    }

    public void run() {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    class FastScanner {

        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
    }

    public static void main(String[] arg) {
        new MainE().run();
    }
}


import java.io.*;
import java.util.*;

public class D {

	static final int MOD = 1000000007;

	static void solve() throws IOException {
		int k = nextInt();
		out.println(get(k));
	}

	private static int get(int k) {
		int answer = 0;

		int maxC = 32;
		int[][] choose = new int[maxC][maxC];
		for (int i = 0; i < maxC; i++) {
			choose[i][0] = choose[i][i] = 1;
			for (int j = 1; j < i; j++) {
				choose[i][j] = add(choose[i - 1][j - 1], choose[i - 1][j]);
			}
		}

		int bitLength = 32 - Integer.numberOfLeadingZeros(k);
		for (int matchWithK = 0; matchWithK <= bitLength; matchWithK++) {
			int bitsRemaining = bitLength - matchWithK;
			int onesTotal = Integer.bitCount(k >> bitsRemaining);

			if (bitsRemaining > 0 && (k & (1 << bitsRemaining - 1)) == 0) {
				continue;
			}

			for (int sizeFirstHalf = 0; sizeFirstHalf <= onesTotal; sizeFirstHalf++) {
				if ((sizeFirstHalf == 0) ^ (matchWithK == 0)) {
					continue;
				}
				int chooseFirstHalf;
				if (matchWithK > 0) {
					chooseFirstHalf = chooseFirstHalf(k >> bitsRemaining,
							sizeFirstHalf);
				} else {
					chooseFirstHalf = 1;
				}

				if (bitsRemaining == 0) {
					answer = add(answer, chooseFirstHalf);
					continue;
				}

				if (matchWithK > 0) {
					chooseFirstHalf = mul(chooseFirstHalf,
							1 << (sizeFirstHalf - 1));
				}
				int[] chooseSecondHalf = numberOfSetsSimple(bitsRemaining - 1);
				for (int sizeSecondHalf = 0; sizeSecondHalf < chooseSecondHalf.length; sizeSecondHalf++) {
					int ways;
					int chooseSecond = chooseSecondHalf[sizeSecondHalf];
					if (matchWithK == 0) {
						ways = 1;
					} else {
						ways = modPow(2, (bitsRemaining - 1 - sizeSecondHalf)
								* sizeFirstHalf);
					}
					ways = mul(ways, chooseSecond);
					ways = mul(ways, chooseFirstHalf);
					answer = add(answer, ways);
				}
			}
		}
		return answer;
	}

	private static int chooseFirstHalf(int mask, int size) {
		int bits = 32 - Integer.numberOfLeadingZeros(mask);
		int[][] dp = new int[bits + 1][size + 1];

		dp[1][1] = 1;
		for (int bit = 2; bit <= bits; bit++) {
			for (int s = 1; s <= size; s++) {
				int ways1 = mul(1 << (s - 1), dp[bit - 1][s]);
				int ways2;
				if ((mask & (1 << bits - bit)) == 0) {
					ways2 = 0;
				} else {
					ways2 = dp[bit - 1][s - 1];
				}
				dp[bit][s] = add(ways1, ways2);
			}
		}
		return dp[bits][size];
	}

	private static int[] numberOfSetsSimple(int bits) {
		int[][] dp = new int[bits + 1][bits + 1];
		dp[0][0] = 1;
		for (int b = 1; b <= bits; b++) {
			dp[b][0] = 1;
			for (int size = 1; size <= b; size++) {
				dp[b][size] = add(dp[b - 1][size],
						mul(dp[b - 1][size - 1], 1 << b - size));
			}
		}
		return dp[bits];
	}

	static int modPow(int a, long pow) {
		int res = 1 % MOD;
		while (pow > 0) {
			if ((pow & 1) != 0) {
				res = mul(res, a);
			}
			a = mul(a, a);
			pow >>= 1;
		}
		return res;
	}

	static int add(int a, int b) {
		a += b;
		if (a >= MOD || a < 0) {
			a -= MOD;
		}
		return a;
	}

	static int mul(int a, int b) {
		return (int) ((long) a * b % MOD);
	}

	static BufferedReader br;
	static StringTokenizer st;
	static PrintWriter out;

	public static void main(String[] args) throws IOException {
		InputStream input = System.in;
		PrintStream output = System.out;
		File file = new File("d.in");
		if (file.exists() && file.canRead()) {
			input = new FileInputStream(file);
		}
		br = new BufferedReader(new InputStreamReader(input));
		out = new PrintWriter(output);
		solve();
		out.close();
	}

	static long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	static double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	static int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	static String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String line = br.readLine();
			if (line == null) {
				return null;
			}
			st = new StringTokenizer(line);
		}
		return st.nextToken();
	}
}


import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Andrey Menkov (nothingelsematters7@gmail.com)
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    private long MOD;

    private long powInd(long a, long n) {
        if (n == 0) return 1;
        if ((n & 1) != 0) return (a * powInd((a * a) % MOD, n / 2)) % MOD;
        return powInd((a * a) % MOD, n / 2) % MOD;
    }

    private long getFibb(long n) {
        long a11 = 1, a12 = 1, a21 = 1, a22 = 0;
        long r11 = 1, r12 = 0;
        long q11 = 0, q12 = 0, q21 = 0, q22 = 0;
        while (n > 0) {
            if ((n & 1) == 1) {
                q11 = (r11 * a11 + r12 * a21) % MOD;
                q12 = (r11 * a12 + r12 * a22) % MOD;
                r11 = q11;
                r12 = q12;
            }
            q11 = (a11 * a11 + a12 * a21) % MOD;
            q12 = (a11 * a12 + a12 * a22) % MOD;
            q21 = (a21 * a11 + a22 * a21) % MOD;
            q22 = (a21 * a12 + a22 * a22) % MOD;
            a11 = q11;
            a12 = q12;
            a21 = q21;
            a22 = q22;

            n >>= 1;
        }
        return r12;
    }

    public void solve(int testNumber, Scanner in, PrintWriter out) {
        long n = in.nextLong(), k = in.nextLong(), l = in.nextLong(), m = in.nextLong();
        MOD = m;

        if (l < 63 && k >= (1L << l)) {
            out.println(0);
            return;
        }

        long fib = getFibb(n + 2);
        long pow = powInd(2, n);
        long res = 1;

        long diff = pow - fib;
        while (diff < 0) diff += MOD;

        for (int bit = 0; bit < l; bit++) {
            if ((k & (1L << bit)) != 0) {
                res = (res * diff) % MOD;
            } else {
                res = (res * fib) % MOD;
            }
        }

        out.println(res % MOD);
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;

/**
 * @author khokharnikunj8
 */

public class Main {
    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                new Main().solve();
            }
        }, "1", 1 << 26).start();
    }

    void solve() {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ScanReader in = new ScanReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AChores solver = new AChores();
        solver.solve(1, in, out);
        out.close();
    }

    static class AChores {
        public void solve(int testNumber, ScanReader in, PrintWriter out) {
            int n = in.scanInt();
            int k = in.scanInt();
            int x = in.scanInt();
            long ans = 0;
            for (int i = 0; i < n - k; i++) ans += in.scanInt();
            ans += (x * k);
            out.println(ans);
        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int index;
        private BufferedInputStream in;
        private int total;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (index >= total) {
                index = 0;
                try {
                    total = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (total <= 0) return -1;
            }
            return buf[index++];
        }

        public int scanInt() {
            int integer = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = scan();
                }
            }
            return neg * integer;
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

    }
}


import java.util.*;
import java.io.*;
import java.math.*;
import java.util.Comparator;
public class Main
{
    public static void main(String[] args)throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer stk =new StringTokenizer(br.readLine());
        int n = Integer.parseInt(stk.nextToken());
        int m = Integer.parseInt(stk.nextToken());
        int[] arr = new int[n];
        stk = new StringTokenizer(br.readLine());

        for(int i=0;i<n;i++){
            arr[i]  =Integer.parseInt(stk.nextToken());
        }

        Arrays.sort(arr);
        int l = 1;
        int r = n;
        long min = Long.MAX_VALUE;
        while(l<=r){
            int mid = (l+r)/2;
            long sum = 0;
            int cnt = 0 ;
            //System.out.println(mid);
            for(int i=n-1; i >= 0 ; i -= mid){
                for(int k=0;k<mid && i - k >=0;k++){
                    sum += Math.max(0,arr[i-k] - cnt);
                }
                cnt++;
            }
            //System.out.println(sum);
            if(sum >= m){
                r = mid -1;
                min = Math.min(mid,min);
            }
            else
                l = mid +1;
        }
        if(min == Long.MAX_VALUE){
            System.out.println(-1);
        }
        else{
            System.out.println(min);
        }
    }
}


import java.util.*;
import java.math.*;
public class codeforces {

         public static void main(String[] args)
        {
                Scanner sc=new Scanner(System.in);
                String data=sc.next();
                int mem[]=new int[10];
                Arrays.fill(mem, 0);
                for(char x:data.toCharArray())
                {
                	int t=x-'0';
                	mem[t]++;
                }
                int num=-1;
                int last=-1;
                for(int i=1;i<=5;i++)
                {
                	if(mem[i]==0||mem[10-i]==0)
                		continue;
                	int temp[]=new int[10];
                	for(int j=0;j<10;j++)
                	{
                		temp[j]=mem[j];
                	}
                	int tt=1;
                	temp[i]--;
                	temp[10-i]--;
                	for(int j=0;j<=4;j++)
                	{
                		int k=Math.min(temp[j], temp[9-j]);
                		k=Math.max(0, k);
                		temp[j]-=k;
                		temp[9-j]-=k;
                		tt+=2*k;
                	}
                    int mem1[]=new int[10];
                    int mem2[]=new int[10];
                    for(int j=0;j<10;j++)
                    {
                    	mem1[j]=temp[j];
                    	mem2[j]=temp[j];
                    }
                    mem1[10-i]++;
                    mem2[i]++;
                    if(mem1[9-i]>0)
                    {
                    	mem1[9-i]--;
                    	mem2[i]--;
                    	tt++;

                    }
                    if(mem2[i-1]>0)
                    {

                    	mem1[10-i]--;
                    	mem2[i-1]--;
                    	tt++;

                    }
                	tt+=Math.min(mem1[0], mem2[0]);
                	if(tt>num)
                	{
                		num=tt;
                		last=i;
                	}
                }
             //   System.out.println(last);
              //  System.out.println(num);
                if(last==-1)
                {
                	for(int i=0;i<2;i++)
                	{
                		for(int j=9;j>=0;j--)
                		{
                			for(int k=0;k<mem[j];k++)
                			{
                				System.out.print(j);
                			}
                		}
                		System.out.println("");
                	}
                	return;
                }
                int len=data.length();
                char num1[]=new char[len];
                char num2[]=new char[len];
                int index=len-1;
                int zero=Math.max(0, mem[0]-mem[9]);
                mem[0]-=zero;
                for(int i=0;i<zero;i++,index--)
                {
                	num1[index]='0';
                	num2[index]='0';
                }
                mem[last]--;
                mem[10-last]--;
                num1[index]=(char)(last+'0');
                num2[index]=(char)(10-last+'0');
                index--;
                for(int i=0;i<=4;i++)
                {
                	int k=Math.min(mem[i], mem[9-i]);
                	k=Math.max(0, k);
                	for(int j=0;j<k;j++)
                	{
                		num1[index]=(char)('0'+i);
                		num2[index]=(char)('0'+9-i);
                		index--;
                		num1[index]=(char)('0'+9-i);
                		num2[index]=(char)('0'+i);
                		index--;
                	}
                	mem[i]-=k;
                	mem[9-i]-=k;
                }
                int mem1[]=new int[10];
                int mem2[]=new int[10];
                for(int i=0;i<10;i++)
                {
                	mem1[i]=mem[i];
                	mem2[i]=mem[i];
                }
                mem1[10-last]++;
                mem2[last]++;
                if(mem1[9-last]>0)
                {
                	num1[index]=(char)('0'+9-last);
                	num2[index]=(char)('0'+last);
                	index--;
                	mem1[9-last]--;
                	mem2[last]--;

                }
                if(mem2[last-1]>0)
                {
                	num1[index]=(char)('0'+10-last);
                	num2[index]=(char)('0'+last-1);
                	mem1[10-last]--;
                	mem2[last-1]--;
                	index--;
                }
            	int index1=index;
            	int index2=index;
                for(int i=0;i<10;i++)
                {

                	for(int j=0;j<mem1[i];j++)
                	{
                		num1[index1]=(char)('0'+i);
                		index1--;
                	}
                	for(int j=0;j<mem2[i];j++)
                	{
                		num2[index2]=(char)('0'+i);
                		index2--;
                	}
                }
                System.out.println(new String(num1));
                System.out.println(new String(num2));
                return;
        }

}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

// Hide-and-Seek
// 2012/04/17
public class _P032E{
	Scanner sc=new Scanner(System.in);

	int INF=1<<28;
	double EPS=1e-9;

	P v, p, w1, w2, m1, m2;

	void run(){
		v=new P(sc.nextInt(), sc.nextInt());
		p=new P(sc.nextInt(), sc.nextInt());
		w1=new P(sc.nextInt(), sc.nextInt());
		w2=new P(sc.nextInt(), sc.nextInt());
		m1=new P(sc.nextInt(), sc.nextInt());
		m2=new P(sc.nextInt(), sc.nextInt());
		solve();
	}

	void solve(){
		println((ok1()||ok2())?"YES":"NO");
	}

	boolean ok1(){
		if(crsSS(p, v, w1, w2)){
			return false;
		}else if(crsSS(p, v, m1, m2)){
			return linear(p, v, m1)&&linear(p, v, m2);
		}else{
			return true;
		}
	}

	boolean ok2(){
		P m=m2.sub(m1);
		if(m.det(p.sub(m1))*m.det(v.sub(m1))<EPS){
			return false;
		}else{
			P h=isLL(m1, m2, p, proj(m1, m2, v).mul(2).sub(v));
			return disSP(m1, m2, h)<EPS&&!crsSS(p, h, w1, w2)
					&&!crsSS(h, v, w1, w2);
		}
	}

	// p1,p2,p3の1直線上判定
	boolean linear(P p1, P p2, P p3){
		return abs(p2.sub(p1).det(p3.sub(p1))/2)<EPS;
	}

	// 線分と点の距離
	double disSP(P p1, P p2, P q){
		if(p2.sub(p1).dot(q.sub(p1))<EPS)
			return q.sub(p1).abs();
		if(p1.sub(p2).dot(q.sub(p2))<EPS)
			return q.sub(p2).abs();
		return disLP(p1, p2, q);
	}

	// 直線と点の距離
	double disLP(P p1, P p2, P q){
		return abs(p2.sub(p1).det(q.sub(p1)))/p2.sub(p1).abs();
	}

	// 線分と線分の交差判定
	boolean crsSS(P p1, P p2, P q1, P q2){
		if(max(p1.x, p2.x)+EPS<min(q1.x, q2.x))
			return false;
		if(max(q1.x, q2.x)+EPS<min(p1.x, p2.x))
			return false;
		if(max(p1.y, p2.y)+EPS<min(q1.y, q2.y))
			return false;
		if(max(q1.y, q2.y)+EPS<min(p1.y, p2.y))
			return false;
		return signum(p2.sub(p1).det(q1.sub(p1)))
				*signum(p2.sub(p1).det(q2.sub(p1)))<EPS
				&&signum(q2.sub(q1).det(p1.sub(q1)))
						*signum(q2.sub(q1).det(p2.sub(q1)))<EPS;
	}

	// 点から直線に下ろした垂線の足
	P proj(P p1, P p2, P q){
		return p1.add(p2.sub(p1).mul(
				p2.sub(p1).dot(q.sub(p1))/p2.sub(p1).abs2()));
	}

	// 直線と直線の交点
	P isLL(P p1, P p2, P q1, P q2){
		double d=q2.sub(q1).det(p2.sub(p1));
		if(abs(d)<EPS)
			return null;
		return p1.add(p2.sub(p1).mul(q2.sub(q1).det(q1.sub(p1))/d));
	}

	class P{
		double x, y;

		P(){
			this(0, 0);
		}

		P(double x, double y){
			this.x=x;
			this.y=y;
		}

		P add(P p){
			return new P(x+p.x, y+p.y);
		}

		P sub(P p){
			return new P(x-p.x, y-p.y);
		}

		P mul(double m){
			return new P(x*m, y*m);
		}

		P div(double d){
			return new P(x/d, y/d);
		}

		double abs(){
			return sqrt(abs2());
		}

		double abs2(){
			return x*x+y*y;
		}

		double arg(){
			return atan2(y, x);
		}

		double dot(P p){
			return x*p.x+y*p.y;
		}

		double det(P p){
			return x*p.y-y*p.x;
		}

		double ang(P p){
			return atan2(det(p), dot(p));
		}

		P rot(double d){
			return new P(cos(d)*x-sin(d)*y, sin(d)*x+cos(d)*y);
		}
	}

	void println(String s){
		System.out.println(s);
	}

	void print(String s){
		System.out.print(s);
	}

	void debug(Object... os){
		System.err.println(Arrays.deepToString(os));
	}

	public static void main(String[] args){
		Locale.setDefault(Locale.US);
		new _P032E().run();
	}
}


import java.io.*;
import java.util.*;

public class Main implements Runnable {

	final static double eps = 1e-7;

	class Point {
		double x, y;
		Point(double x, double y) {
			this.x = x;
			this.y = y;
		}
		Point add(Point o) {
			return new Point(x + o.x, y + o.y);
		}
		Point sub(Point o) {
			return new Point(x - o.x, y - o.y);
		}
		Point scale(double f) {
			return new Point(x * f, y * f);
		}
		double len() {
			return Math.sqrt(x * x + y * y);
		}
	}

	double dot(Point a, Point b) {
		return a.x * b.x + a.y * b.y;
	}

	double cross(Point a, Point b) {
		return a.x * b.y - a.y * b.x;
	}

	boolean onSegment(Point x, Point a, Point b) {
		if (!zero(cross(a.sub(x), b.sub(x))))
			return false;
		return dot(a.sub(x), b.sub(x)) <= eps;
	}

	Point linesIntersection(Point a, Point b, Point c, Point d) {
		double d1 = cross(c.sub(a), b.sub(a));
		double d2 = cross(d.sub(a), b.sub(a));
		if (Math.abs(d1 - d2) < eps)
			return null;
		return (d.scale(d1).sub(c.scale(d2))).scale(1 / (d1 - d2));
	}

	boolean segsIntersect(Point a, Point b, Point c, Point d) {
		Point p = linesIntersection(a, b, c, d);
		if (p == null)
			return false;
		return onSegment(p, a, b) && onSegment(p, c, d);
	}

	boolean zero(double x) {
		return Math.abs(x) < eps;
	}

	int sign(double x) {
		if (zero(x)) return 0;
		return x < 0 ? -1 : 1;
	}

	Point reflect(Point x, Point a, Point b) {
		Point v = x.sub(a);
		Point dir = b.sub(a);
		dir = dir.scale(1 / dir.len());
		Point pr = dir.scale(dot(dir, v));
		return a.add(pr.scale(2).sub(v));
	}

	public void _main() throws IOException {
		Point v = new Point(nextDouble(),nextDouble());
		Point p = new Point(nextDouble(),nextDouble());
		Point w1 = new Point(nextDouble(),nextDouble());
		Point w2 = new Point(nextDouble(),nextDouble());
		Point m1 = new Point(nextDouble(),nextDouble());
		Point m2 = new Point(nextDouble(),nextDouble());

		if (!segsIntersect(v, p, w1, w2) && !onSegment(w1, v, p) && !onSegment(w2, v, p)) {
			if (zero(cross(m1.sub(v), m1.sub(p))) &&
				zero(cross(m2.sub(v), m2.sub(p))) ||
				!segsIntersect(v, p, m1, m2))
			{
				out.print("YES");
				return;
			}
		}

		int sideV = sign(cross(v.sub(m1), m2.sub(m1)));
		int sideP = sign(cross(p.sub(m1), m2.sub(m1)));
		if (sideV != sideP) {
			out.print("NO");
			return;
		}
		Point ref = linesIntersection(v, reflect(p, m1, m2), m1, m2);
		if (ref == null || !onSegment(ref, m1, m2)) {
			out.print("NO");
			return;
		}
		out.println((!segsIntersect(p, ref, w1, w2) && !segsIntersect(v, ref, w1, w2)) ? "YES" : "NO");
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;

	private String next() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String rl = in.readLine();
			if (rl == null)
				return null;
			st = new StringTokenizer(rl);
		}
		return st.nextToken();
	}

	private int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	private long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	private double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	public static void main(String[] args) {
		Locale.setDefault(Locale.UK);
		new Thread(new Main()).start();
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);

			_main();

			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(202);
		}
	}

}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.util.StringTokenizer;

public class b implements Runnable {

	Vec me, other;
	Seg wall, mirror;

	double getAngle(Vec a, Vec mid, Vec b) {
		Vec u = a.sub(mid), v = b.sub(mid);
		//u.v = |u|*|v|*cos(theta)
		//theta = arccos((u.v)/(|u|*|v|))
		return Math.acos(u.dot(v) / u.mag() / v.mag());
	}

	double go(double scale) {
		Vec unit = mirror.dir.unit();
		Vec leftmost = mirror.from.sub(unit);
		Vec rightmost = mirror.to.add(unit);
		Vec pt = mirror.from.add(unit.scale(scale));
		double left = getAngle(me, pt, leftmost);
		double right = getAngle(other, pt, rightmost);
		return Math.abs(left - right);
	}

	public void solve(FS in, PrintWriter out) {
		me = new Vec(in.nextDouble(), in.nextDouble());
		other = new Vec(in.nextDouble(), in.nextDouble());
		wall = new Seg(new Vec(in.nextDouble(), in.nextDouble()), new Vec(in.nextDouble(), in.nextDouble()));
		mirror = new Seg(new Vec(in.nextDouble(), in.nextDouble()), new Vec(in.nextDouble(), in.nextDouble()));

		Seg meOther = new Seg(me, other);
		if(!meOther.intersects(wall, true) && !meOther.intersects(mirror, false)) {
			out.println("YES");
			return;
		}
		if(meOther.intersects(mirror, false)) {
			out.println("NO");
			return;
		}

		double lo = 0, hi = mirror.dir.mag();
		for(int it = 0; it < 2000; ++it) {
			double delta = (hi - lo) / 3;
			double m1 = lo + delta, m2 = hi - delta;
			double leftDiff = go(m1), rightDiff = go(m2);
			if(leftDiff < rightDiff) hi = m2;
			else lo = m1;
		}

		Vec mirrorPt = mirror.from.add(mirror.dir.unit().scale(lo));
		double diff = go(lo);
		if(diff > 1e-6) {
			out.println("NO");
			return;
		}

		if(!mirror.containsPoint(mirrorPt)) {
			out.println("NO");
			return;
		}
		Seg meMirror = new Seg(me, mirrorPt);
		Seg otherMirror = new Seg(other, mirrorPt);
		if(meMirror.intersects(wall, true) || otherMirror.intersects(wall, true)) {
			out.println("NO");
			return;
		}
		out.println("YES");
	}

	public void run() {
		System.err.println("go!");
		FS in = new FS();
		PrintWriter out = new PrintWriter(System.out);
		solve(in, out);
		out.close();
	}

	static class Vec {
		static final double EPS=1e-6;
		double x, y;

		public Vec(double x, double y) {
			this.x=x;
			this.y=y;
		}

		public Vec add(Vec o) {
			return new Vec(x+o.x, y+o.y);
		}

		public Vec sub(Vec o) {
			return new Vec(x-o.x, y-o.y);
		}

		public Vec scale(double s) {
			return new Vec(x*s, y*s);
		}

		public double dot(Vec o) {
			return x*o.x+y*o.y;
		}

		public double cross(Vec o) {
			return x*o.y-y*o.x;
		}

		public double mag2() {
			return dot(this);
		}

		public double mag() {
			return Math.sqrt(mag2());
		}

		public Vec unit() {
			return scale(1/mag());
		}

		public Vec rot90() {
			return new Vec(-y, x);
		}

		public Vec rot270() {
			return new Vec(y, -x);
		}

		public Vec rotate(double theta) {
			double PI=Math.PI;
			double newX=x*Math.cos(theta)+y*Math.cos(PI/2+theta);
			double newY=x*Math.sin(theta)+y*Math.sin(PI/2+theta);
			return new Vec(newX, newY);
		}

		//angle between 0 and 2PI
		public double angle() {
			return (Math.atan2(y, x)+2*Math.PI)%(2*Math.PI);
		}

		public String toString() {
			DecimalFormat df=new DecimalFormat("#.##");
			return "("+df.format(x)+", "+df.format(y)+")";
		}

		static boolean eq(double a, double b) {
			return Math.abs(a-b)<EPS;
		}

		static boolean leq(double a, double b) {
			return a-EPS<b;
		}

		static boolean geq(double a, double b) {
			return a+EPS>b;
		}

		public boolean equals(Object oo) {
			Vec o=(Vec)oo;
			return eq(x, o.x)&&eq(y, o.y);
		}
	}

	static class Seg {
		Vec from, to, dir;

		public Seg(Vec from, Vec to) {
			this.from=from;
			this.to=to;
			dir=to.sub(from);
		}

		//line-line intersection
		public Vec lineIntersect(Seg o) {
			double det=o.dir.x*dir.y-dir.x*o.dir.y;
			if (Vec.eq(det, 0)) return null;
			double dist=(o.dir.x*(o.from.y-from.y)-
					o.dir.y*(o.from.x-from.x))/det;
			return from.add(dir.scale(dist));
		}

		public boolean containsPoint(Vec o) {
			double distFromLine=dir.unit().cross(o.sub(from));
			if (!Vec.eq(distFromLine, 0)) return false;
			return Vec.eq(dir.mag(), from.sub(o).mag()+to.sub(o).mag());
		}

		//seg-seg intersection
		public Vec segIntersection(Seg o) {
			Vec intersect=lineIntersect(o);
			return containsPoint(intersect)&&o.containsPoint(intersect)?intersect:null;
		}

		//returns 1 if above, 0 if on, -1 if below
		public int side(Vec o) {
			Vec oDir=o.sub(from);
			double distFromLine=dir.unit().cross(oDir);
			if (Vec.eq(distFromLine, 0))
				return 0;
			return (int)Math.signum(distFromLine);
		}

		public boolean intersects(Seg o, boolean isWall) {
			if(isWall && (containsPoint(o.from) || containsPoint(o.to))) return true;
			return side(o.from)!=side(o.to) && o.side(from)!=o.side(to);
		}

		public Vec getClosestTo(Vec o) {
			double percentThere=o.sub(from).dot(dir)/dir.mag2();
			return from.add(dir.scale(Math.max(0, Math.min(1, percentThere))));
		}

		public Vec projectToLine(Vec o) {
			return dir.scale(o.sub(from).dot(dir)/dir.mag2()).add(from);
		}

		//toContain must be a point with positive x and y coordinates.
		//this method returns the shortest line segment from the x-axis to the point to the y axis
		static Seg getShortestSegFromAxesContainingQ1Point(Vec toContain) {
			double slope=-Math.pow(toContain.y/toContain.x, 1.0/3);
			double b=toContain.y-toContain.x*slope;
			double xInt=-b/slope;
			return new Seg(new Vec(0, b), new Vec(xInt, 0));
		}

		public String toString() {
			return from+" -> "+to;
		}
	}

	public static void main(String[] args) {
		new Thread(null, new b(), "lmao", 1L<<28).start();
	}
	static class FS {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer("");
		String next() {
			while(!st.hasMoreElements()) {
				try { st = new StringTokenizer(br.readLine()); }
				catch(Exception e) {}
			}
			return st.nextToken();
		}
		int nextInt() {
			return Integer.parseInt(next());
		}
		double nextDouble() {
			return Double.parseDouble(next());
		}
	}
}


import java.io.*;
import java.util.*;

public class F implements Runnable{
	public static void main (String[] args) {new Thread(null, new F(), "_cf", 1 << 28).start();}

	public void run() {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);

		int oo = (int)2e9;
		int n = fs.nextInt();
		int k = fs.nextInt();
		int[] dp = new int[n + 1], tdp = new int[n + 1];
		Arrays.fill(dp, oo);
		dp[0] = 0;
		while(k-->0) {
			int l = fs.nextInt(), r = fs.nextInt(), len = r - l;
			for(int i = 0; i <= n; i++) tdp[i] = dp[i];
			ArrayDeque<Integer> minQueue = new ArrayDeque<>();
			for(int i = 0; i <= n; i++) {
				push(minQueue, i, dp);
				tdp[i] = Math.min(tdp[i], best(minQueue, dp) + 2);
				if(r - i >= 0 && r - i <= n) tdp[r - i] = Math.min(tdp[r - i], best(minQueue, dp) + 1);
				pop(minQueue, i - len);
			}
			for(int i = 0; i <= n; i++) dp[i] = tdp[i];
		}

		if(dp[n] >= oo) out.println("Hungry");
		else out.printf("Full\n%d\n", dp[n]);

		out.close();
	}

	void pop(ArrayDeque<Integer> minQueue, int idx) {
		if(!minQueue.isEmpty() && minQueue.peekFirst() == idx) minQueue.pollFirst();
	}

	int best(ArrayDeque<Integer> minQueue, int[] dp) {
		if(minQueue.isEmpty()) return (int)2e9;
		return dp[minQueue.peekFirst()];
	}

	void push(ArrayDeque<Integer> minQueue, int p, int[] dp) {
		while(!minQueue.isEmpty() && dp[minQueue.getLast()] >= dp[p]) minQueue.pollLast();
		minQueue.addLast(p);
	}

	/*
	 * dp[i][j] means the minimum number of moves to cook the cutlet on one side
	   for j seconds after processing i intervals (do iterative space saving)
	 * The length of the interval is known and so we'll build up time j with the
	   previous length values (including j) all from the previous state. It'll take
	   an extra 2 flips to so:
	   if we know the number of flips to get the cutlet to exactly t seconds and we
	   want to get it to j seconds in the current interval being processed, then we'll
	   need to flip it after it gets to t seconds in the other interval (to prevent overcooking)
	   and then flip it again when it needs to cook in our interval to get it to the desired j.
	 * There's also a case where we can just flip it once based off of the previous states.
	   The main idea for some time j, is we want the cutlet to get to its jth second of cooking
	   during our current interval (so we can do a flip if necessary). So what happens is we take
	   the min of the dp values that are allowed in our current range and use that value to calculate
	   (right - j)'s best value by taking that minimum and I guess not flipping it and instead letting
	   it cook. Still a bit hazy but it makes sense when doing the second sample by hand (especially
	   when we update times 10 and 8).
	 * Definitely had to study someone else's solution because the editorial is very obscure and
	   doesn't actually explain the important part of the problem (how to derive the +1 and +2 jumps).
	 */

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				//                br = new BufferedReader(new FileReader("testdata.out"));
				st = new StringTokenizer("");
			} catch (Exception e){e.printStackTrace();}
		}
		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}
		public int nextInt() {return Integer.parseInt(next());}
		public long nextLong() {return Long.parseLong(next());}
		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			try {line = br.readLine();}
			catch (Exception e) {e.printStackTrace();}
			return line;
		}
		public Integer[] nextIntegerArray(int n) {
			Integer[] a = new Integer[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		public char[] nextCharArray() {return nextLine().toCharArray();}
	}

}


import java.io.DataInputStream;
import java.io.IOException;

public class Task939F {

    public static class FastScanner {

        protected DataInputStream dataInputStream;
        protected byte[] buffer = new byte[0x10000];
        protected int bufferOffset;
        protected int bufferLength;
        protected boolean isEndOfFile;

        public FastScanner() throws IOException {
            dataInputStream = new DataInputStream(System.in);
            Read();
        }

        protected void Read() throws IOException {
            final int length = dataInputStream.read(buffer);
            if (length > 0) {
                bufferLength = length;
            } else {
                bufferLength = 0;
                isEndOfFile = true;
            }
            bufferOffset = 0;
        }

        protected byte nextByte() throws IOException {
            if (bufferOffset == bufferLength) {
                if (!isEndOfFile) Read();
                if (isEndOfFile) return 0;
            }
            return buffer[bufferOffset++];
        }

        public int nextInt() throws IOException {
            int a = 0;
            boolean isNegative = false;

            byte b = nextByte();
            while (b <= ' ') b = nextByte();
            if (b == '-') {
                isNegative = true;
                b = nextByte();
            }
            while (b > ' ') {
                a = a * 10 + (b - '0');
                b = nextByte();
            }
            return isNegative ? -a : a;
        }

    }

    public static void SaveRotates(final int num) {
        if (minNumRotates == 0) minNumRotates = num;
        else minNumRotates = Math.min(minNumRotates, num);
    }

    public static void CalcRotates(int side, final int[] tmin, final int[] tmax,
                                  int noffset, int koffset, boolean isInterval) {
        if (tmin[0] > n || tmin[1] > n) return;
        else if ((tmin[0] <= n && tmax[0] >= n) || (tmin[1] <= n && tmax[1] >= n)) {
            if ((tmax[0] < n && side == 1) || (tmax[1] < n && side == 0)) {
                SaveRotates(numRotates + 1);
            } else {
                SaveRotates(numRotates);
            }
            return;
        } else if (koffset == k) return;

        if (isInterval) {
            if (kbeg[koffset] == kend[koffset]) {
                // no rotate
                CalcRotates(side, tmin, tmax, noffset, koffset + 1, false);

                // rotate
                numRotates++;
                CalcRotates(1 - side, tmin, tmax, noffset, koffset + 1, false);
                numRotates--;

            } else {
                // no rotate
                tmin[side] += kend[koffset] - kbeg[koffset];
                tmax[side] += kend[koffset] - kbeg[koffset];
                CalcRotates(side, tmin, tmax, kend[koffset], koffset + 1, false);
                tmin[side] -= kend[koffset] - kbeg[koffset];
                tmax[side] -= kend[koffset] - kbeg[koffset];

                // rotate once
                tmax[side] += kend[koffset] - kbeg[koffset];
                tmax[1 - side] += kend[koffset] - kbeg[koffset];
                numRotates++;
                CalcRotates(1 - side, tmin, tmax, kend[koffset], koffset + 1, false);
                numRotates--;
                tmax[side] -= kend[koffset] - kbeg[koffset];
                tmax[1 - side] -= kend[koffset] - kbeg[koffset];

                // rotate twice
                tmax[side] += kend[koffset] - kbeg[koffset];
                tmin[1 - side] += 1;
                tmax[1 - side] += kend[koffset] - kbeg[koffset] - 1;
                numRotates += 2;
                CalcRotates(side, tmin, tmax, kend[koffset], koffset + 1, false);
                numRotates -= 2;
                tmax[side] -= kend[koffset] - kbeg[koffset];
                tmin[1 - side] -= 1;
                tmax[1 - side] -= kend[koffset] - kbeg[koffset] - 1;

            }

        } else {
            tmin[side] += kbeg[koffset] - noffset;
            tmax[side] += kbeg[koffset] - noffset;
            CalcRotates(side, tmin, tmax, kbeg[koffset], koffset, true);
            tmin[side] -= kbeg[koffset] - noffset;
            tmax[side] -= kbeg[koffset] - noffset;
        }
    }

    public static int[] kbeg;
    public static int[] kend;
    public static int n = 0;
    public static int k = 0;
    public static int numRotates = 0;
    public static int minNumRotates = 0;

    public static void main(final String[] args) throws IOException {
        final FastScanner scanner = new FastScanner();
        n = scanner.nextInt();
        k = scanner.nextInt();

        kbeg = new int[k];
        kend = new int[k];

        for (int i = 0; i < k; i++) {
            kbeg[i] = scanner.nextInt();
            kend[i] = scanner.nextInt();
        }
        final int[] tmin = new int[2];
        final int[] tmax = new int[2];

        CalcRotates(0, tmin, tmax, 0, 0, false);
        if (minNumRotates > 0) {
            System.out.println("Full");
            System.out.println(minNumRotates);
        } else {
            System.out.println("Hungry");
        }
    }
}


import java.io.*;
import java.util.*;

/*
TASK: cutlet
LANG: JAVA
 */
public class cutlet {
    static int n , k , lo , hi;
    static int[][] segs;
    static int[] l , delt;
    static int[][][] dp;
    static ArrayList<int[]> finSeg = new ArrayList<int[]>();
    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        n = in.nextInt();
        k = in.nextInt();
        segs = new int[k][2];
        for(int i = 0;i < k; i++){
            segs[i][0] = in.nextInt();
            segs[i][1] = in.nextInt();
        }
        Arrays.sort(segs, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
        for(int i = 0;i < k; i++){
            lo = segs[i][0];
            hi = segs[i][0];
            while(i < k && segs[i][0] <= hi)hi = Math.max(hi , segs[i++][1]);
            int[] add = {lo , hi};
            finSeg.add(add);
            i--;
        }
        k = finSeg.size();
        segs = new int[k][2];
        l = new int[k];
        delt = new int[k];
        for(int i = 0;i < k; i++)segs[i] = finSeg.get(i);
        for(int i = 0;i < k; i++){
            l[i] = segs[i][1] - segs[i][0];
            delt[i] = i < k-1 ? segs[i+1][0] - segs[i][1] : 2*n - segs[i][1];
        }
        dp = new int[2][k+1][2*n+1];
        for(int i = 0;i < 2*n+1; i++){
            dp[0][k][i] = n;
            dp[1][k][i] = n;
        }
        dp[0][k][n] = 0;
        dp[1][k][n] = 0;
        RMQ[] rmq = new RMQ[2];
        rmq[0] = new RMQ(dp[0][k]);
        rmq[1] = new RMQ(dp[1][k]);
        for(int i = k-1; i >= 0; i--){
            for(int j = 0;j <= 2*n; j++){
                dp[0][i][j] = j+l[i]+delt[i] <= 2*n ? dp[0][i+1][j+l[i]+delt[i]] : n;
                dp[1][i][j] = dp[1][i+1][j];
                dp[0][i][j] = Math.min(dp[0][i][j] , 1 + rmq[1].min(j , Math.min(j+l[i] , 2*n)));
                if(j + delt[i] <= 2*n)dp[1][i][j] = Math.min(dp[1][i][j] , 1 + rmq[0].min(j + delt[i] , Math.min(j+l[i] + delt[i] , 2*n)));
                if(j + delt[i] <= 2*n)dp[0][i][j] = Math.min(dp[0][i][j] , 2 + rmq[0].min(j + delt[i] , Math.min(j+l[i] + delt[i] , 2*n)));
                dp[1][i][j] = Math.min(dp[1][i][j] , 2 + rmq[1].min(j , Math.min(j+l[i] , 2*n)));
            }
            rmq[0] = new RMQ(dp[0][i]);
            rmq[1] = new RMQ(dp[1][i]);
        }
        int ans = dp[1][0][0];
        if(ans == n)System.out.println("Hungry");
        else {
            System.out.println("Full");
            System.out.println(ans);
        }

    }
    public static class RMQ{
        int n , k;
        int[][] min;
        public RMQ(int[] a){
            n = a.length;
            k = Integer.numberOfTrailingZeros(Integer.highestOneBit(n))+1;
            min = new int[k][n];
            for(int i = 0;i < n; i++)
                min[0][i] = a[i];
            for(int i = 1; i < k; i++){
                for(int j = 0;j + (1 << i-1) < n; j++){
                    min[i][j] = Math.min(min[i-1][j] , min[i-1][j + (1 << i-1)]);
                }
            }
        }
        public int min(int a , int b){
            int z = Integer.numberOfTrailingZeros(Integer.highestOneBit(b-a+1));
            return Math.min(min[z][a] , min[z][b - (1<<z) + 1]);
        }
    }
    private static class FastScanner {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public FastScanner(InputStream stream) {
            this.stream = stream;
        }

        int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) return -1;
            }
            return buf[curChar++];
        }

        boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        boolean isEndline(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String next() {
            int c = read();
            while (isSpaceChar(c)) c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public String nextLine() {
            int c = read();
            while (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskF solver = new TaskF();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskF {
        int MAX = (int) (1e9);

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            int k = in.nextInt();
            ArrayList<int[]> interval = new ArrayList<>();
            for (int i = 0; i < k; i++) {
                interval.add(new int[]{in.nextInt(), in.nextInt()});
            }
            interval.add(new int[]{2 * N, 2 * N});
            int cur = 0;
            SegmentTree[] dp = new SegmentTree[2]; //how many sides are fried on the front, 0 is currently on front, 1 is currently on back
            dp[0] = new SegmentTree(N + 1);
            dp[1] = new SegmentTree(N + 1);
            dp[0].assign(0, 0);
            for (int i = 0; i < interval.size(); i++) {
                for (int j = N; j >= 0; j--) {
                    dp[0].assign(j, dp[0].getVal(j - (interval.get(i)[0] - cur)));
                }
                cur = interval.get(i)[1];
                int sz = interval.get(i)[1] - interval.get(i)[0];
                for (int j = N; j >= 0; j--) {
                    int[] put = new int[2];
                    for (int z = 0; z <= 1; z++) {
                        int twoSwaps = dp[z].query(j - sz, j);
                        int oneSwap = dp[(z + 1) % 2].query(j - sz, j);
                        int noSwap;
                        if (z == 1) {
                            noSwap = dp[z].getVal(j);
                        } else {
                            noSwap = dp[z].getVal(j - sz);
                        }
                        put[z] = Math.min(twoSwaps + 2, Math.min(oneSwap + 1, noSwap));
                    }
                    dp[0].assign(j, put[0]);
//                out.println(j + " " + put[0] + " " + put[1]);
                    dp[1].assign(j, put[1]);
                }
            }
            int ans = Math.min(dp[0].query(N, N), dp[1].query(N, N));
            if (ans >= MAX) {
                out.println("Hungry");
            } else {
                out.println("Full");
                out.println(ans);
            }
        }

        class SegmentTree {
            int[] tree;
            int[] arr;
            int size = 0;

            public SegmentTree(int N) {
                tree = new int[4 * N];
                arr = new int[N];
                Arrays.fill(arr, MAX);
                size = N;
                for (int i = 0; i < 4 * N; i++) {
                    tree[i] = MAX;
                }
            }

            public int query(int l, int r) {
                if (r < 0) {
                    return MAX;
                }
                return queryUtil(1, 0, size - 1, Math.max(0, l), r);
            }

            public int queryUtil(int n, int tl, int tr, int l, int r) {
                //node number, cur range of node, cur range of query
                if (l > r) {
                    return MAX;
                }
                if (tl == l && tr == r) {
                    return tree[n];
                }
                int tm = (tl + tr) / 2;
                return Math.min(queryUtil(2 * n, tl, tm, l, Math.min(r, tm)), queryUtil(2 * n + 1, tm + 1, tr, Math.max(tm + 1, l), r));
            }

            public void assign(int n, int val) {
                arr[n] = val;
                int tl = 0;
                int tr = size - 1;
                int a = 1;
                while (tl < tr) {
                    int tm = (tl + tr) >> 1;
                    if (n <= tm) {
                        tr = tm;
                        a = 2 * a;
                    } else {
                        tl = tm + 1;
                        a = 2 * a + 1;
                    }
                }
                tree[a] = val;
                a >>= 1;
                while (a > 0) {
                    tree[a] = Math.min(tree[2 * a], tree[2 * a + 1]);
                    a >>= 1;
                }
            }

            int getVal(int i) {
                if (i < 0) {
                    return MAX;
                }
                return arr[i];
            }

        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}


import java.io.*;
import java.util.Arrays;

/**
 * Created by dalt on 2018/3/14.
 */
public class CF939F {
    public static final int INF = (int) 1e8;
    public static BlockReader input;
    public static PrintStream output;

    public static void main(String[] args) throws FileNotFoundException {
        if (System.getProperty("ONLINE_JUDGE") == null) {
            input = new BlockReader(new FileInputStream("D:\\DataBase\\TESTCASE\\codeforces\\CF939F.in"));
            output = System.out;
        } else {
            input = new BlockReader(System.in);
            output = new PrintStream(new BufferedOutputStream(System.out), false);
        }

        solve();

        output.flush();
    }

    public static void solve() {
        int n = input.nextInteger();
        int k = input.nextInteger();

        int[][] intervals = new int[k + 2][2];
        for (int i = 1; i <= k; i++) {
            intervals[i][0] = input.nextInteger();
            intervals[i][1] = input.nextInteger();
        }
        intervals[k + 1][0] = 2 * n;
        intervals[k + 1][1] = 2 * n;

        k++;

        Node[] loop = new Node[2];
        loop[0] = Node.build(0, n);
        loop[1] = Node.build(0, n);

        int[] data = new int[n + 1];

        for (int i = 1; i <= k; i++) {
            Node curDp = loop[i & 1];

            Node lastDp = loop[(i - 1) & 1];

            int[] interval = intervals[i];
            int intervalLength = interval[1] - interval[0];
            int middleLength = interval[0] - intervals[i - 1][1];

            Node.toArray(0, n, data, lastDp);
            System.arraycopy(data, 0, data, Math.min(data.length, intervalLength + middleLength), Math.max(0, n + 1 - (intervalLength + middleLength)));
            Arrays.fill(data, 0, Math.min(data.length, intervalLength + middleLength), INF);

            //No flip
/*            for (int j = intervalLength + middleLength; j <= n; j++) {
                int lastFryTotalTime = j - intervalLength - middleLength;
                int minNeedTime = Node.query(lastFryTotalTime, lastFryTotalTime, 0, n, lastDp);
                Node.update(j, 0, n, minNeedTime, curDp);
            }*/

            int minX = interval[1] - middleLength - intervalLength;
            int maxX = interval[1] - middleLength;
            for (int j = 0; j <= n; j++) {
                //Flip once
                int minNeedTime = Node.query(minX - j, maxX - j, 0, n, lastDp);
                data[j] = Math.min(data[j], minNeedTime + 1);
               // Node.update(j, 0, n, minNeedTime + 1, curDp);
            }

            for (int j = 0; j <= n; j++) {
                //Flip twice
                int minNeedTime = Node.query(j - middleLength - intervalLength, j - middleLength, 0, n, lastDp);
                //Node.update(j, 0, n, minNeedTime + 2, curDp);
                data[j] = Math.min(data[j], minNeedTime + 2);
            }

            Node.fromArray(0, n, data, curDp);
        }

        int minFlipTime = Node.query(n, n, 0, n, loop[k & 1]);

        if (minFlipTime < INF) {
            output.println("Full");
            output.println(minFlipTime);
        } else {
            output.println("Hungry");
        }
    }

    public static class Node {
        Node left;
        Node right;
        int batchSetValue;
        boolean dirty;
        int min;

        public static void setValue(int f, int t, int l, int r, int val, Node node) {
            if (f > r || t < l) {
                return;
            }
            if (f <= l && t >= r) {
                node.setValue(val);
                return;
            }

            node.pushDown();
            int m = (l + r) >> 1;
            setValue(f, t, l, m, val, node.left);
            setValue(f, t, m + 1, r, val, node.right);

            node.pushUp();
        }

        public static Node build(int l, int r) {
            Node node = new Node();
            if (l != r) {
                int m = (l + r) >> 1;
                node.left = build(l, m);
                node.right = build(m + 1, r);
            }
            return node;
        }

        public static int query(int f, int t, int l, int r, Node node) {
            if (f > r || t < l) {
                return INF;
            }
            if (f <= l && r <= t) {
                return node.min;
            }
            node.pushDown();
            int m = (l + r) >> 1;
            return Math.min(query(f, t, l, m, node.left), query(f, t, m + 1, r, node.right));
        }

        public static void update(int i, int l, int r, int val, Node node) {
            if (i > r || i < l) {
                return;
            }
            if (i <= l && i >= r) {
                node.min = Math.min(node.min, val);
                return;
            }

            node.pushDown();
            int m = (l + r) >> 1;
            update(i, l, m, val, node.left);
            update(i, m + 1, r, val, node.right);

            node.pushUp();
        }

        public static void toArray(int l, int r, int[] data, Node node) {
            if (l == r) {
                data[l] = node.min;
                return;
            }
            node.pushDown();
            int m = (l + r) >> 1;
            toArray(l, m, data, node.left);
            toArray(m + 1, r, data, node.right);
        }

        public static void fromArray(int l, int r, int[] data, Node node) {
            if (l == r) {
                node.min = data[l];
                return;
            }

            node.dirty = false;
            int m = (l + r) >> 1;
            fromArray(l, m, data, node.left);
            fromArray(m + 1, r, data, node.right);
            node.pushUp();
        }

        public void pushUp() {
            this.min = Math.min(left.min, right.min);
        }

        public void setValue(int val) {
            this.min = val;
            this.batchSetValue = val;
            this.dirty = true;
        }

        public void pushDown() {
            if (dirty) {
                left.setValue(batchSetValue);
                right.setValue(batchSetValue);
                dirty = false;
            }
        }

        @Override
        public String toString() {
            int t = 100;
            int[] data = new int[t + 1];
            for (int i = 0; i <= t; i++) {
                data[i] = query(i, i, 0, t, this);
            }
            return Arrays.toString(data);
        }
    }

    public static class BlockReader {
        static final int EOF = -1;
        InputStream is;
        byte[] dBuf;
        int dPos, dSize, next;
        StringBuilder builder = new StringBuilder();

        public BlockReader(InputStream is) {
            this(is, 4096);
        }

        public BlockReader(InputStream is, int bufSize) {
            this.is = is;
            dBuf = new byte[bufSize];
            next = nextByte();
        }

        public int nextByte() {
            while (dPos >= dSize) {
                if (dSize == -1) {
                    return EOF;
                }
                dPos = 0;
                try {
                    dSize = is.read(dBuf);
                } catch (Exception e) {
                }
            }
            return dBuf[dPos++];
        }

        public String nextBlock() {
            builder.setLength(0);
            skipBlank();
            while (next != EOF && !Character.isWhitespace(next)) {
                builder.append((char) next);
                next = nextByte();
            }
            return builder.toString();
        }

        public void skipBlank() {
            while (Character.isWhitespace(next)) {
                next = nextByte();
            }
        }

        public int nextInteger() {
            skipBlank();
            int ret = 0;
            boolean rev = false;
            if (next == '+' || next == '-') {
                rev = next == '-';
                next = nextByte();
            }
            while (next >= '0' && next <= '9') {
                ret = (ret << 3) + (ret << 1) + next - '0';
                next = nextByte();
            }
            return rev ? -ret : ret;
        }

        public int nextBlock(char[] data, int offset) {
            skipBlank();
            int index = offset;
            int bound = data.length;
            while (next != EOF && index < bound && !Character.isWhitespace(next)) {
                data[index++] = (char) next;
                next = nextByte();
            }
            return index - offset;
        }

        public boolean hasMore() {
            skipBlank();
            return next != EOF;
        }
    }
}