Problem: Berkomnadzor — Federal Service for Supervision of Communications, Information Technology and Mass Media — is a Berland federal executive body that protects ordinary residents of Berland from the threats of modern internet.

Berkomnadzor maintains a list of prohibited IPv4 subnets (blacklist) and a list of allowed IPv4 subnets (whitelist). All Internet Service Providers (ISPs) in Berland must configure the network equipment to block access to all IPv4 addresses matching the blacklist. Also ISPs must provide access (that is, do not block) to all IPv4 addresses matching the whitelist. If an IPv4 address does not match either of those lists, it's up to the ISP to decide whether to block it or not. An IPv4 address matches the blacklist (whitelist) if and only if it matches some subnet from the blacklist (whitelist). An IPv4 address can belong to a whitelist and to a blacklist at the same time, this situation leads to a contradiction (see no solution case in the output description).

An IPv4 address is a 32-bit unsigned integer written in the form a.b.c.d, where each of the values a,b,c,d is called an octet and is an integer from 0 to 255 written in decimal notation. For example, IPv4 address 192.168.0.1 can be converted to a 32-bit number using the following expression 192 ⋅ 2^{24} + 168 ⋅ 2^{16} + 0 ⋅ 2^8 + 1 ⋅ 2^0. First octet a encodes the most significant (leftmost) 8 bits, the octets b and c — the following blocks of 8 bits (in this order), and the octet d encodes the least significant (rightmost) 8 bits.

The IPv4 network in Berland is slightly different from the rest of the world. There are no reserved or internal addresses in Berland and use all 2^{32} possible values.

An IPv4 subnet is represented either as a.b.c.d or as a.b.c.d/x (where 0 ≤ x ≤ 32). A subnet a.b.c.d contains a single address a.b.c.d. A subnet a.b.c.d/x contains all IPv4 addresses with x leftmost (most significant) bits equal to x leftmost bits of the address a.b.c.d. It is required that 32 - x rightmost (least significant) bits of subnet a.b.c.d/x are zeroes.

Naturally it happens that all addresses matching subnet a.b.c.d/x form a continuous range. The range starts with address a.b.c.d (its rightmost 32 - x bits are zeroes). The range ends with address which x leftmost bits equal to x leftmost bits of address a.b.c.d, and its 32 - x rightmost bits are all ones. Subnet contains exactly 2^{32-x} addresses. Subnet a.b.c.d/32 contains exactly one address and can also be represented by just a.b.c.d.

For example subnet 192.168.0.0/24 contains range of 256 addresses. 192.168.0.0 is the first address of the range, and 192.168.0.255 is the last one.

Berkomnadzor's engineers have devised a plan to improve performance of Berland's global network. Instead of maintaining both whitelist and blacklist they want to build only a single optimised blacklist containing minimal number of subnets. The idea is to block all IPv4 addresses matching the optimised blacklist and allow all the rest addresses. Of course, IPv4 addresses from the old blacklist must remain blocked and all IPv4 addresses from the old whitelist must still be allowed. Those IPv4 addresses which matched neither the old blacklist nor the old whitelist may be either blocked or allowed regardless of their accessibility before. 

Please write a program which takes blacklist and whitelist as input and produces optimised blacklist. The optimised blacklist must contain the minimal possible number of subnets and satisfy all IPv4 addresses accessibility requirements mentioned above. 

IPv4 subnets in the source lists may intersect arbitrarily. Please output a single number -1 if some IPv4 address matches both source whitelist and blacklist.

Input

The first line of the input contains single integer n (1 ≤ n ≤ 2⋅10^5) — total number of IPv4 subnets in the input.

The following n lines contain IPv4 subnets. Each line starts with either '-' or '+' sign, which indicates if the subnet belongs to the blacklist or to the whitelist correspondingly. It is followed, without any spaces, by the IPv4 subnet in a.b.c.d or a.b.c.d/x format (0 ≤ x ≤ 32). The blacklist always contains at least one subnet.

All of the IPv4 subnets given in the input are valid. Integer numbers do not start with extra leading zeroes. The provided IPv4 subnets can intersect arbitrarily.

Output

Output -1, if there is an IPv4 address that matches both the whitelist and the blacklist. Otherwise output t — the length of the optimised blacklist, followed by t subnets, with each subnet on a new line. Subnets may be printed in arbitrary order. All addresses matching the source blacklist must match the optimised blacklist. All addresses matching the source whitelist must not match the optimised blacklist. You can print a subnet a.b.c.d/32 in any of two ways: as a.b.c.d/32 or as a.b.c.d.

If there is more than one solution, output any.

Examples

Input

1
-149.154.167.99


Output

1
0.0.0.0/0


Input

4
-149.154.167.99
+149.154.167.100/30
+149.154.167.128/25
-149.154.167.120/29


Output

2
149.154.167.99
149.154.167.120/29


Input

5
-127.0.0.4/31
+127.0.0.8
+127.0.0.0/30
-195.82.146.208/29
-127.0.0.6/31


Output

2
195.0.0.0/8
127.0.0.4/30


Input

2
+127.0.0.1/32
-127.0.0.1


Output

-1

Solution (in JAVA):

Solution:
import org.omg.PortableInterceptor.SUCCESSFUL;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class SolverB {

    StringTokenizer stok;
    BufferedReader br;
    PrintWriter pw;

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

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

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

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

    private void run() throws IOException {
//        br = new BufferedReader(new FileReader("input.txt"));
//        pw = new PrintWriter("output.txt");
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        solve();
        pw.flush();
        pw.close();
    }

    public static void main(String[] args) throws IOException {
        new SolverB().run();
    }

    class Node {
        boolean hasBlack = false;
        boolean hasWhite = false;
        Node[] childs = new Node[2];
    }

    class Subnet {
        long addr;
        int mask;

        public Subnet() {

        }

        public Subnet(String str) {
            String[] parts = str.split("/");
            String address = parts[0];
            if (parts.length == 1) {
                mask = 32;
            } else {
                mask = Integer.parseInt(parts[1]);
            }
            String[] octets = address.split("\\.");
            for (int i = 0; i<4; i++) {
                addr = addr * 256 + Long.parseLong(octets[i]);
            }
        }

        @Override
        public String toString() {
            int[] octets = new int[4];
            long address = addr;
            for (int i=3; i>=0; i--) {
                octets[i] = (int) (address % 256);
                address /= 256;
            }
            StringBuilder sb = new StringBuilder();
            for (int i=0; i<4; i++) {
                sb.append(octets[i]);
                if (i<3) {
                    sb.append(".");
                }
            }
            sb.append("/");
            sb.append(mask);
            return sb.toString();
        }
    }

    int n;
    Node root = new Node();
    String[] list;
    List<Subnet> resultList = new ArrayList<>();

    private void addBlack(Node node, Subnet subnet, int dep) {
        if (subnet.mask == dep) {
            node.hasBlack = true;
            return;
        }

        int ind = Long.compare(subnet.addr & (1l << (31 - dep)), 0);
        if (node.childs[ind] == null) {
            node.childs[ind] = new Node();
        }
        addBlack(node.childs[ind], subnet, dep + 1);
    }

    private boolean addWhite(Node node, Subnet subnet, int dep) {
        if (node == null) {
            return true;
        }
        if (node.hasBlack) {
            return false;
        }

        node.hasWhite = true;
        if (subnet.mask == dep) {
            return node.childs[0] == null && node.childs[1] == null;
        }
        int ind = Long.compare(subnet.addr & (1l << (31 - dep)), 0);
        return addWhite(node.childs[ind], subnet, dep + 1);
    }

    private Subnet findResult(Node node, int dep, long curAddr) {
        if (node == null) {
            return null;
        }

        Subnet res1 = findResult(node.childs[0], dep + 1, curAddr);
        Subnet res2 = findResult(node.childs[1], dep + 1, curAddr + (1L << (31 - dep)));
        Subnet result = null;
        if (res1 != null || res2 != null) {
            if (node.hasWhite) {
                if (res1 != null) {
                    resultList.add(res1);
                }
                if (res2 != null) {
                    resultList.add(res2);
                }
                return null;
            } else {
                result = new Subnet();
                result.mask = dep;
                result.addr = curAddr;
            }
        }
        if (result == null && node.hasBlack) {
            result = new Subnet();
            result.mask = dep;
            result.addr = curAddr;
        }
        return result;
    }

    private void solve() throws IOException {
        n = nextInt();
        list = new String[n];
        for (int i=0; i<n; i++) {
            list[i] = br.readLine();
        }
        for (int i=0; i<n; i++) {
            if (list[i].startsWith("-")) {
                Subnet subnet = new Subnet(list[i].substring(1));
                addBlack(root, subnet, 0);
            }
        }

        for (int i=0; i<n; i++) {
            if (list[i].startsWith("+")) {
                Subnet subnet = new Subnet(list[i].substring(1));
                if (!addWhite(root, subnet, 0)) {
                    pw.println(-1);
                    return;
                }
            }
        }

        Subnet subnet = findResult(root, 0, 0);
        if (subnet != null) {
            resultList.add(subnet);
        }
        pw.println(resultList.size());
        for (Subnet subnet1 : resultList) {
            pw.println(subnet1);
        }
    }
}