Anastasia loves going for a walk in Central Uzhlyandian Park. But she became uninterested in simple walking, so she began to collect Uzhlyandian pebbles. At first, she decided to collect all the pebbles she could find in the park.

She has only two pockets. She can put at most k pebbles in each pocket at the same time. There are n different pebble types in the park, and there are wi pebbles of the i-th type. Anastasia is very responsible, so she never mixes pebbles of different types in same pocket. However, she can put different kinds of pebbles in different pockets at the same time. Unfortunately, she can't spend all her time collecting pebbles, so she can collect pebbles from the park only once a day.

Help her to find the minimum number of days needed to collect all the pebbles of Uzhlyandian Central Park, taking into consideration that Anastasia can't place pebbles of different types in same pocket.

Input

The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 109) — the number of different pebble types and number of pebbles Anastasia can place in one pocket.

The second line contains n integers w1, w2, ..., wn (1 ≤ wi ≤ 104) — number of pebbles of each type. 

Output

The only line of output contains one integer — the minimum number of days Anastasia needs to collect all the pebbles.

Examples

Input

3 2
2 3 4


Output

3


Input

5 4
3 1 8 9 7


Output

5

Note

In the first sample case, Anastasia can collect all pebbles of the first type on the first day, of second type — on the second day, and of third type — on the third day.

Optimal sequence of actions in the second sample case: 

  * In the first day Anastasia collects 8 pebbles of the third type. 
  * In the second day she collects 8 pebbles of the fourth type. 
  * In the third day she collects 3 pebbles of the first type and 1 pebble of the fourth type. 
  * In the fourth day she collects 7 pebbles of the fifth type. 
  * In the fifth day she collects 1 pebble of the second type. 
 // Importing all important imports
     
    import java.awt.Point;
    import static java.lang.System.in;
    import java.io.BufferedReader;
    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintStream;
    import java.io.PrintWriter;
    import java.math.BigInteger;
    import java.math.BigDecimal;
    import java.math.MathContext;
    import java.math.RoundingMode;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.BitSet;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.Date;
    import java.util.GregorianCalendar;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Hashtable;
    import java.util.InputMismatchException;
    import java.util.LinkedHashMap;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Stack;
    import java.util.Queue;
    import java.util.Random;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import java.util.Set;
    import java.util.SortedSet;
    import java.util.StringTokenizer;
    import java.util.TreeMap;
    import java.util.TreeSet;
    import java.util.Vector;
     
     
     
    /**
    @author
    * 
    $$\      $$\            $$$$$$\            
    $$$\    $$$ |          $$  __$$\           
    $$$$\  $$$$ | $$$$$$$\ $$ /  \__|  
    $$\$$\$$ $$ |$$  _____|$$$$\      
    $$ \$$$  $$ |\$$$$$$\  $$  _|     
    $$ |\$  /$$ | \____$$\ $$ |      
    $$ | \_/ $$ |$$$$$$$  |$$ |      
    \__|     \__|\_______/ \__|       
    *
    * @Mustafa Filmwala
    * @filmwalams@gmail.com
    * https://github.com/filmwalams/JAVA-Functions
    * 
    * 
    */
     
public class Main{
            
            static boolean testcase=false;
            static boolean debug_mode=false;
            static String input_file_name="";
            static String output_file_name="";
            
            //static String input_file_name="input.txt";
            //static String output_file_name="output.txt";
            
            public int mod=1000000007;
            public long id(int a , int b){
                return (long)a*1000000007 + b;
            }
        
            public void solve(int tc) throws IOException{   
               // int n = ni();
                int n = ni(),k = ni();
                int ans = 0;
                for(int i = 0;i< n;i++){
                    int x = ni();
                    ans+= x/k;
                    if(x % k != 0)ans++;
                }
                out.println((ans+1)/2);
            }
            
     
            // END OF SOLUTION
            
            public void precompute(){}
            
            
            // INPUT OUTPUT TEMPLATE
            static String TESTCASES="";
            static PrintWriter out;
            static int Space;
            
            public static void main(String[] args) throws Exception{
                    // generateTestCases(1); 
                    long endTime,startTime=System.currentTimeMillis();
                    if(output_file_name.isEmpty())
                        out=new PrintWriter(new OutputStreamWriter(System.out));
                    else
                        out = new PrintWriter(new FileOutputStream("/home/filmwalams/Desktop/CONTEST/"+output_file_name));
                    //if(!input_file_name.isEmpty()){
                    //  mytestcases();
                    //}
                    InputStream myinp=TESTCASES.isEmpty() ? System.in : new ByteArrayInputStream(TESTCASES.getBytes());
                    init(myinp);
                    
                    Space=0;
                    Main program=new Main();
                    
                    program.precompute();
                    if(testcase==true){int test=ni();for(int tc=1;tc<=test;tc++)program.solve(tc);}
                    else program.solve(0);
                    
                    out.close();
                    endTime=System.currentTimeMillis();
                    //printTime("Time: "+(endTime-startTime)+"ms");
            }
            
            // Testcases reader from FILE. If file not found, input is taken from console.
            public static void mytestcases(){
                
                try{
                    TESTCASES=new String(Files.readAllBytes(Paths.get("/home/filmwalams/Desktop/CONTEST/"+input_file_name)));
                }
                catch(Exception e){
                    TESTCASES="";
                }
            }
            
            public static void generateTestCases(int count){
                
                PrintStream console=System.out;
                try{
                    PrintStream out = new PrintStream(new FileOutputStream("/home/filmwalams/Downloads"));
                
                    System.setOut(out);
                    Random r=new Random();
                    // System.out.println(count);
                    for(int tc=0;tc<count;tc++){
                           
                    }
                    System.setOut(console);
                }
                catch(FileNotFoundException fe){
                    System.setOut(console);
                }
            }
              
              
            // Just to print time, not to use anywhere else
            public static void printTime(Object ...obj){System.err.println(Arrays.deepToString(obj));}
            static InputStream is;
            static BufferedReader brr;
            protected static byte[] inbuf = new byte[1024];
            static int lbuffer = 0, pbuffer = 0;
            public static void init(InputStream input) {is=input;brr=new BufferedReader(new InputStreamReader(input));}
            // Fundamental
            protected static int rb(){if(lbuffer == -1)throw new InputMismatchException();if(pbuffer >= lbuffer){pbuffer = 0;try { lbuffer = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }if(lbuffer <= 0)return -1;}return inbuf[pbuffer++];}       
            protected static String line() throws IOException{return brr.readLine();}   
            protected static boolean isSpace(int c) { return !(c >= 33 && c <= 126); }
            protected static int skip(){ int b; while((b = rb()) != -1 && isSpace(b)); return b; }
            // Inputs
            protected static double nd() throws IOException { return Double.parseDouble(ns()); }
            protected static char nc() { return (char)skip(); }
            protected static String ns() throws IOException{if(Space==1)return line();int b = skip();StringBuilder sb = new StringBuilder();while(!(isSpace(b))){ sb.appendCodePoint(b);b = rb();}return sb.toString();}
            protected static char[] nca(int n){char[] buf = new char[n];int b = skip(), p = 0;while(p < n && !(isSpace(b))){buf[p++] = (char)b;b = rb();} return n == p ? buf : Arrays.copyOf(buf, p);}
            protected static int[] nia(int n) throws IOException{int[] a = new int[n];for(int i = 0;i < n;i++)a[i] = ni();return a;}
            protected static int[][] niaindex(int n) throws IOException{int ea[][]=new int[n][2];for(int i=0;i<n;i++){ea[i][0]=ni();ea[i][1]=i;}return ea;}
            protected static long[] nla(int n) throws IOException{long[] a = new long[n];for(int i = 0;i < n;i++)a[i] = nl();return a;}
            protected static long[][] nlaindex(int n) throws IOException{long ea[][]=new long[n][2];for(int i=0;i<n;i++){ea[i][0]=ni();ea[i][1]=i;}return ea;}
            protected static String[] nsa(int n) throws IOException{String[] a = new String[n];for(int i = 0;i < n;i++)a[i] = ns();return a;    }
            protected static double[] nda(int n) throws IOException{double[] a = new double[n];for(int i = 0;i < n;i++)a[i] = nd();return a;}
            protected static int ni() throws IOException{if(Space==1)return Integer.parseInt(line());int num=0,b;boolean minus = false;while((b = rb())!= -1 && !((b>='0'&&b<='9') || b =='-'));if(b =='-'){minus=true;b = rb();    }while(true){if(b >= '0' && b <= '9'){num = num * 10 + (b - '0');}else{return minus ? -num : num;}b = rb();}}  
            protected static long nl() throws IOException{if(Space==1)return Long.parseLong(line());long num = 0;int b;boolean minus = false;while((b = rb()) != -1 && !((b >= '0' && b <= '9') || b == '-'));if(b == '-'){   minus = true;b = rb();}while(true){if(b >= '0' && b <= '9'){num = num * 10 + (b - '0');}else{return minus ? -num : num;}b = rb();}}
            // Outputs
            public static void pln(){out.println();}
            public static void ps(String s){out.print(s);}
            public static void pi(int s){out.print(s);}
            public static void pl(long s){out.print(s);}
            public static void pd(double s){out.print(s);}
            public static void psp(){out.print(" ");}
            public static void parr(int s[]){out.println(Arrays.toString(s));}
            public static void parr(String s[]){out.println(Arrays.toString(s));}
            public static void parr(long s[]){out.println(Arrays.toString(s));}        
            public static void parr2(int s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
            public static void parr2(long s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
            public static void parr2(String s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
            
            
    }   