9 13
6 14 19 5 -5 6 -10 20 8
 8 9
6 -1 5 -5 -8 -7 -8 -7
 10 7
-9 3 -4 -22 4 -17 0 -14 3 -2
 6 2
-2 3 0 -2 0 0
 5 10
-8 -24 0 -22 12
 5 13756
-2 -9 -10 0 10
 7 3
1 -3 0 3 -1 0 2
 9 9
-3 2 0 -2 -7 -1 0 5 3
 2 3
2 0
 19 78701
1 0 -1 0 -1 -1 0 1 0 -1 1 1 -1 1 0 0 -1 0 0
 5 4
-1 0 0 1 -1
 6 4
-1 0 2 -4 0 5
 20 23036
-1 1 -1 -1 -1 -1 1 -1 -1 0 0 1 1 0 0 1 0 0 -1 -1
 5 4
-1 0 -3 0 3
 12 82016
1 -2 -1 -1 -2 -1 0 -2 -1 1 -2 2
 7 4
-6 0 2 -3 0 4 0
 4 4
2 2 0 1
 6 1
-3 0 0 0 -2 3
 8 26
-4 9 -14 -11 0 7 23 -15
 20 23079
0 1 1 -1 1 0 -1 -1 0 0 1 -1 1 1 1 0 0 1 0 1
 1 1
1
 7 8555
-2 -3 -2 3 0 -2 0
 4 100
-100 0 -50 100
 3 14
12 12 -8
 1 1
2
 10 23
9 7 14 16 -13 -22 24 -3 -12 14
 8 11
12 -12 -9 3 -22 -21 1 3
 19 49926
-2 0 2 0 0 -2 2 -1 -1 0 0 0 1 0 1 1 -2 2 2
 16 76798
-1 11 -7 -4 0 -11 -12 3 0 -7 6 -4 8 6 5 -10
 9 5
-2 0 3 -4 0 4 -3 -2 0

-1
 -1
 1
 1
 1
 1
 -1
 2
 0
 1
 1
 -1
 1
 1
 1
 1
 -1
 1
 -1
 0
 0
 1
 1
 -1
 -1
 -1
 -1
 1
 1
 1

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

public class D33 {
    public static void main(String[] args) {
        InputReader in = new InputReader();
        OutputWriter out = new OutputWriter(System.out);
        int n = in.nextInt();
        int d = in.nextInt();
        int a[] = new int[n];
        int bal[] = new int[n];
        a[0] = in.nextInt();
        bal[0] = a[0];
        for(int i = 1; i < n; ++i) {
        	a[i] = in.nextInt();
        	bal[i] = bal[i - 1] + a[i];
        	if(bal[i] > d) {
        		System.out.println(-1);
        		return;
        	}
        }
        SegmentTree tree = new SegmentTree(bal);
        int days = 0;
        for(int i = 0; i < n; ++i) {
        	if(a[i] == 0 && tree.max(i, i) < 0) {
        		if(i == n-1) {
        			days++;
        		} else {
	        		int add = d - tree.max(i + 1, n - 1);
	        		if(tree.max(i, i) + add < 0) {
	        			System.out.println(-1);
	        			return;
	        		} else {
	        			tree.add(i, n-1, add);
	        			days++;
	        		}
        		}
        	}
        }
        System.out.println(days);
    }
    
    private static class SegmentTree {
    	private int max[];
    	private int lpos[];
    	private int rpos[];
    	private int add[];
    	private final int root = 1;
    	
    	SegmentTree(int[] arr) {
    		max = new int[arr.length * 4];
    		lpos =new int[arr.length * 4];
    		rpos = new int[arr.length * 4]; 
    		add = new int[arr.length * 4];
    		build(root, arr, 0, arr.length - 1);
    	}
    	
    	private void build(int v, int[] arr, int left, int right) {
    		lpos[v] = left;
    		rpos[v] = right;
    		if(left == right) {
    			max[v] = arr[left];
    		} else {
    			int middle = (left + right) / 2;
    			build(v * 2, arr, left, middle);
    			build(v * 2 + 1, arr, middle + 1, right);
    			update(v);
    		}
    	}
    	
    	private void update(int v) {
    		max[v] = Integer.max(max[v * 2 ], max[v * 2 + 1]);
    	}
    	
    	void add(int from, int to, int value) {
    		add(root, from, to, value);
    	}
    	
    	private void add(int v, int from, int to, int value) {
    		if(lpos[v] >= from && rpos[v] <= to) {
    			addValue(v, value);
    		} else {
    			push(v);
    			from = Integer.max(from, lpos[v]);
    			to = Integer.min(to, rpos[v]);
    			if(from <= to) {
    				add(v * 2, from, to, value);
    				add(v * 2 + 1, from, to, value);
    				update(v);
    			}
    		}
    	}
    	
    	private void push(int v) {
    		if(add[v] != 0) {
    			addValue(v * 2, add[v]);
    			addValue(v * 2 + 1, add[v]);
    			add[v] = 0;
    		}
    	}
    	
    	private void addValue(int v, int value) {
			max[v] += value;
			if(lpos[v] != rpos[v]) {
				add[v] += value;
			}
    	}
    	
    	int max(int from, int to) {
    		return max(root, from, to);
    	}
    	
    	private int max(int v, int from, int to) {
    		if(lpos[v] >= from && rpos[v] <= to) {
    			return max[v];
    		} else {
    			push(v);
    			from = Integer.max(from, lpos[v]);
    			to = Integer.min(to, rpos[v]);
    			if(from > to) {
    				return Integer.MIN_VALUE;
    			}
    			return Integer.max(max(v * 2, from, to), max(v * 2 + 1, from, to));
    		}
    	}
    }

    public static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void printf(String format, Object... objects) {
            writer.printf(format, objects);
        }

        public void close() {
            writer.close();
        }

        public void flush() {
            writer.flush();
        }

    }
    
    static class InputReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public InputReader()
        {
            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;
        }
    }
}


