Problem: Dima's spent much time thinking what present to give to Inna and gave her an empty sequence w. Now they want to fill sequence w with numbers zero and one. For that, they decided to play an amusing game. 

Before the game begins, Dima chooses m integers a1, a2, ..., am (1 ≤ a1 < a2 < ... < am). Then Inna and Dima start playing, that is, adding numbers to sequence w. Each new number they choose is added to the end of the sequence. At some moments of time Dima feels that the game is going to end too soon (and he wants to play with Inna as long as possible), so he hits a table hard with his fist. At that the a1-th, a2-th, a3-th, ..., ak-th numbers from the beginning simultaneously fall out of the sequence (the sequence gets k numbers less). Here k is such maximum number that value ak doesn't exceed the current length of the sequence. If number a1 is larger than the current length of w, then nothing falls out of the sequence.

You are given the chronological sequence of events in the game. Each event is either adding a number to the end of sequence w or Dima's hit on the table. Calculate the sequence w after all these events happen.

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 106) showing how many events took place and how many numbers Dima chose.

The next line contains m distinct integers ai (1 ≤ ai ≤ 106) sorted in the increasing order. 

Next n lines describe the events in the chronological order. Each line contains a single integer: -1, 0 or 1. Number -1 means that Dima hits the table. Number 0 means that Inna and Dima add number 0 to the end of the sequence. Number 1 means that Inna and Dima add number 1 to the end of the sequence.

Output

In a single line print a sequence of numbers 0 and 1 — the elements of the sequence after all events happen. Print the elements of the sequence in the order from the beginning to the end of the sequence.

If after all events the sequence ends up empty, print "Poor stack!".

Examples

Input

10 3
1 3 6
-1
1
1
0
0
-1
0
1
-1
1


Output

011


Input

2 1
1
1
-1


Output

Poor stack!

Solution (in JAVA):

Solution:
import java.io.*;
import static java.lang.Math.*;

import java.lang.reflect.Array;
import java.util.*;
import java.util.function.*;
import java.lang.*;

public class Main {
    final static String fileName = "";
    final static boolean useFiles = false;

    public static void main(String[] args) throws FileNotFoundException {
        InputStream inputStream;
        OutputStream outputStream;
        if (useFiles) {
            inputStream = new FileInputStream(fileName + ".in");
            outputStream = new FileOutputStream(fileName + ".out");
        } else {
            inputStream = System.in;
            outputStream = System.out;
        }
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task(in, out);
        solver.solve();
        out.close();
    }
}
class Task {
    int lowerBound(int[] a, int x){
        int l = 0, r = a.length;
        while (r - l > 1){
            int m = (l + r) / 2;
            if (a[m] <= x)
                l = m;
            else
                r = m;
        }
        return l;
    }

    public void solve() {
        int n = in.nextInt(), m = in.nextInt();
        int[] a = new int[m];
        for (int i = 0; i < m; i++)
            a[i] = in.nextInt() - 1;

        byte[] b = new byte[n];
        Arrays.fill(b, (byte) -1);
        int tb = 0;
        SegmentTreeSum tree = new SegmentTreeSum(n);
        for (int op = 0; op < n; op++) {
            byte type = in.nextByte();
            if (type == -1) {
                int sum = tree.get(0, n - 1);
                if (a[0] <= sum - 1) {
                    int ix = lowerBound(a, sum - 1);
                    for (int i = ix; i >= 0; i--) {
                        int j = tree.search(a[i] + 1);
                        tree.set(j, -1);
                        b[j] = -1;
                    }
                }
            } else {
                b[tb] = type;
                tree.set(tb, 1);
                tb++;
            }
//            out.print(type + " ");
//            for (int i = 0; i < n; i++){
//                if (b[i] != -1)
//                    out.print(b[i]);
//            }
//            out.print("tree: ");
//            out.print(tree.toString());
//            out.println();
        }
        int i;
        for (i = 0; i < n && b[i] == -1; i++);
        if (i == n) {
            out.println("Poor stack!");
        } else {
            for (int j = 0; j < n; j++) {
                if (b[j] != -1)
                    out.print(b[j]);
            }
        }
    }

    private InputReader in;
    private PrintWriter out;

    Task(InputReader in, PrintWriter out) {
        this.in = in;
        this.out = out;
    }
}

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 double nextDouble(){
        return Double.parseDouble(next());
    }

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

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

    public byte nextByte(){
        return Byte.parseByte(next());
    }
}
class SegmentTreeSum {
    private int[] t;
    private int n;

    SegmentTreeSum(int n) {
        this.n = n;
        t = new int[n << 2];
    }

    SegmentTreeSum(int[] array) {
        n = array.length;
        build(0, 0, n - 1, array);
    }

    private void build(int v, int tl, int tr, int[] array) {
        if (tr == tl) {
            t[v] = array[tl];
        } else {
            int tm = (tl + tr) >> 1;
            build(2 * v + 1, tl, tm, array);
            build(2 * v + 2, tm + 1, tr, array);
            t[v] = t[2 * v + 1] + t[2 * v + 2];
        }
    }

    int get(int l, int r) {
        if (l > n || r > n || 0 > l || 0 > r)
            throw new IllegalArgumentException("indices: (" + l + ", " + r + ") . Bounds: (0, "+ (n - 1));
        return get(0, 0, n - 1, l, r);
    }

    void set(int index, int value) {
        if (0 > index || index > n)
            throw new IllegalArgumentException("index: " + index + ". Bounds: " + (n - 1));
        set(0, 0, n - 1, index, value);
    }

    int search(int value) {
        return search(0, 0, n - 1, value);
    }

    private int search(int v, int tl, int tr, int value) {
        if (tl == tr)
            return tr;

        int tm = (tl + tr) / 2;
        if (value <= t[2 * v + 1])
            return search(2 * v + 1, tl, tm, value);
        return search(2 * v + 2, tm + 1, tr, value - t[2 * v + 1]);
    }

    private int get(int v, int tl, int tr, int l, int r) {
        if (l > r)
            return 0;
        if (tl == l && tr == r)
            return t[v];
        int tm = (tl + tr) >> 1;
        return get(2 * v + 1, tl, tm, l, Math.min(tm, r)) +
                get(2 * v + 2, tm + 1, tr, Math.max(tm + 1, l), r);
    }

    private void set(int v, int tl, int tr, int index, int value) {
        if (tr == tl)
            t[v] += value;
        else {
            int tm = (tl + tr) >> 1;
            if (index <= tm)
                set(2 * v + 1, tl, tm, index, value);
            else
                set(2 * v + 2, tm + 1, tr, index, value);
            t[v] = t[2 * v + 1] + t[2 * v + 2];
        }
    }

    public int[] toArray() {
        int[] result = new int[n];
        for (int i = 0; i < n; i++)
            result[i] = get(i, i);
        return result;
    }

    @Override
    public String toString() {
        String result = "";
        for (int i = 0; i < n; i++)
            result += get(i, i) + " ";
        return result;
    }
}