Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.

Petya wonders eagerly what minimum lucky number has the sum of digits equal to n. Help him cope with the task.

Input

The single line contains an integer n (1 ≤ n ≤ 106) — the sum of digits of the required lucky number.

Output

Print on the single line the result — the minimum lucky number, whose sum of digits equals n. If such number does not exist, print -1.

Examples

Input

11


Output

47


Input

10


Output

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

public class Codeforces {

    private static Print writer;

    private static Scan reader;

    static class Scan {
        private byte[] buf = new byte[1024]; // Buffer of Bytes
        private int index;
        private InputStream in;
        private int total;

        public Scan() throws IOException {
            in = System.in;
        }

        private int next() throws IOException { // Scan method used to scan buf
            if (total < 0)
                throw new InputMismatchException();
            if (index >= total) {
                index = 0;
                total = in.read(buf);
                if (total <= 0)
                    return -1;
            }
            return buf[index++];
        }

        int ni() throws IOException {
            int integer = 0;
            int n = next();
            while (isWhiteSpace(n)) // Removing startPointing whitespaces
                n = next();
            int neg = 1;
            if (n == '-') { // If Negative Sign encounters
                neg = -1;
                n = next();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = next();
                } else
                    throw new InputMismatchException();
            }
            return neg * integer;
        }

        long nl() throws IOException {
            long integer = 0;
            int n = next();
            while (isWhiteSpace(n)) // Removing startPointing whitespaces
                n = next();
            int neg = 1;
            if (n == '-') { // If Negative Sign encounters
                neg = -1;
                n = next();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = next();
                } else
                    throw new InputMismatchException();
            }
            return neg * integer;
        }

        String line() throws IOException {
            StringBuilder sb = new StringBuilder();
            int n = next();
            while (isWhiteSpace(n))
                n = next();
            while (!isNewLine(n)) {
                sb.append((char) n);
                n = next();
            }
            return sb.toString();
        }

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

        private boolean isWhiteSpace(int n) {
            return n == ' ' || isNewLine(n) || n == '\t';
        }

        int[] nia(int n) throws Exception {
            if (n < 0)
                throw new Exception("Array size should be non negative");
            int[] array = new int[n];
            for (int i = 0; i < n; i++)
                array[i] = ni();
            return array;
        }

        int[][] n2dia(int r, int c) throws Exception {
            if (r < 0 || c < 0)
                throw new Exception("Array size should be non negative");
            int[][] array = new int[r][c];
            for (int i = 0; i < r; i++)
                array[i] = nia(c);
            return array;
        }

        long[] nla(int n) throws Exception {
            if (n < 0)
                throw new Exception("Array size should be non negative");
            long[] array = new long[n];
            for (int i = 0; i < n; i++)
                array[i] = nl();
            return array;
        }

        float[] nfa(int n) throws Exception {
            if (n < 0)
                throw new Exception("Array size should be non negative");
            float[] array = new float[n];
            for (int i = 0; i < n; i++)
                array[i] = nl();
            return array;
        }

        double[] nda(int n) throws Exception {
            if (n < 0)
                throw new Exception("Array size should be non negative");
            double[] array = new double[n];
            for (int i = 0; i < n; i++)
                array[i] = nl();
            return array;
        }
    }

    static class Print {
        private final BufferedWriter bw;

        Print() {
            bw = new BufferedWriter(new OutputStreamWriter(System.out));
        }

        <T> void print(T str) {
            try {
                bw.append(str.toString());
            } catch (IOException e) {
                System.out.println(e.toString());
            }
        }

        void println() {
            print("\n");
        }

        <T> void println(T str) {
            print(str + "\n");
        }

        void flush() throws IOException {
            bw.flush();
        }

        void close() {
            try {
                bw.close();
            } catch (IOException e) {
                System.out.println(e.toString());
            }
        }
    }

    public static void main(String[] args) throws Exception {
        long startPointTime = System.currentTimeMillis();
        reader = new Scan();
        writer = new Print();
        main2();
        long endTime = System.currentTimeMillis();
        float totalProgramTime = endTime - startPointTime;
        if (args.length > 0 && args[0].equals("time"))
            writer.print("Execution time is " + totalProgramTime + " (" + (totalProgramTime / 1000) + "s)");
        writer.close();
    }

    static class DisjointSet {
        int[] arr;
        int[] size;

        DisjointSet(int n) {
            arr = new int[n + 1];
            size = new int[n + 1];
            makeSet();
        }

        void makeSet() {
            for (int i = 1; i < arr.length; i++) {
                arr[i] = i;
                size[i] = 1;
            }
        }

        void union(int i, int j) {
            if (i == j)
                return;
            if (i > j) {
                i ^= j;
                j ^= i;
                i ^= j;
            }

            i = find(i);
            j = find(j);

            if (i == j)
                return;
            arr[j] = arr[i];
            size[i] += size[j];
            size[j] = size[i];
        }

        int find(int i) {
            if (arr[i] != i) {
                arr[i] = find(arr[i]);
                size[i] = size[arr[i]];
            }
            return arr[i];
        }

        int getSize(int i) {
            i = find(i);
            return size[i];
        }

        public String toString() {
            return Arrays.toString(arr);
        }
    }

    static long MOD = 1_000_000_007L;

    static class Line {
        int from;
        int to;

        Line(int from, int to) {
            if (from > to) {
                this.from = to;
                this.to = from;
            } else {
                this.from = from;
                this.to = to;
            }
        }

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

    static String wub = "WUB";

    static void main2() throws Exception {
        int n = reader.ni();
        int x = 0;
        int y = -1;
        while(true) {
            int val = n - 4 * x;
            if(val < 0) break;
            if(val % 7 == 0) {
                writer.println(ans(x, val/7));
                return;
            }
            x++;
        }
        writer.println(-1);
    }
    static String ans(int x, int y) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < x; i++) {
            sb.append(4);
        }
        for (int i = 0; i < y; i++) {
            sb.append(7);
        }
        return sb.toString();
    }

    static int min(int... arr) {
        int min = Integer.MAX_VALUE;
        for (int var : arr) {
            min = Math.min(min, var);
        }
        return min;
    }

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