Paul hates palindromes. He assumes that string s is tolerable if each its character is one of the first p letters of the English alphabet and s doesn't contain any palindrome contiguous substring of length 2 or more.

Paul has found a tolerable string s of length n. Help him find the lexicographically next tolerable string of the same length or else state that such string does not exist.

Input

The first line contains two space-separated integers: n and p (1 ≤ n ≤ 1000; 1 ≤ p ≤ 26). The second line contains string s, consisting of n small English letters. It is guaranteed that the string is tolerable (according to the above definition).

Output

If the lexicographically next tolerable string of the same length exists, print it. Otherwise, print "NO" (without the quotes).

Examples

Input

3 3
cba


Output

NO


Input

3 4
cba


Output

cbd


Input

4 4
abcd


Output

abda

Note

String s is lexicographically larger (or simply larger) than string t with the same length, if there is number i, such that s1 = t1, ..., si = ti, si + 1 > ti + 1.

The lexicographically next tolerable string is the lexicographically minimum tolerable string which is larger than the given one.

A palindrome is a string that reads the same forward or reversed.
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.SortedSet;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Code {
    public static void main(String[] args) {
        // Use the Scanner class
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = sc.nextInt();
        int p = sc.nextInt();
        char[] S = sc.nextLine().toCharArray();

        int i = n -1;
        while (i != -1) {
            char cur = S[i];
            Character prev = i-1 >=0 ? S[i-1] : null;
            Character prev_prev = i-2 >=0 ? S[i-2] : null;
            Character  candidate = get_next(cur, prev, prev_prev, p);
            if (candidate == null) {
                i--;
            } else {
                S[i] = candidate;
                break;
            }
        }
        if (i == -1) {
            System.out.println("NO");
            return;
        }
        i++;
        while (i != n) {
            Character prev = i-1 >=0 ? S[i-1] : null;
            Character prev_prev = i-2 >=0 ? S[i-2] : null;
            Character candidate = get_first(prev, prev_prev, p);
            if (candidate == null) {
                System.out.println("NO");
                return;
            } else {
                S[i++] = candidate;
            }
        }

        System.out.println(new String(S));
    }

    static Character get_next(char c, Character  prev, Character prev_prev, int p) {
        Character res = (char)(c + 1);
        while (res == prev || res == prev_prev) {
            res++;
        }
        if (res > 'a' + p - 1) {
            return null;
        } else {
            return res;
        }
    }

    static Character get_first(Character prev, Character prev_prev, int p) {
        Character c = 'a';
        while (c == prev || c == prev_prev) {
            c++;
        }
        if (c  > 'a' + p - 1) {
            return null;
        } else {
            return c;
        }
    }

    static Sequence find_sequence(SortedSet<Sequence> bst, int idx, boolean type) {
        Sequence target = new Sequence();
        target.last_idx = idx;
        SortedSet<Sequence> hs = bst.headSet(target);
        Sequence ans = hs.isEmpty() ? null : hs.last();
        //System.out.println(String.format("For idx %d found sequence %s", idx, ans));
        return ans;
    }

    static class Sequence implements Comparable<Sequence> {
        List<Integer> idx;
        int last_idx;

        public Sequence() {
            idx = new ArrayList<>();
            last_idx = 0;
        }

        @Override
        public int compareTo(Sequence o) {
            return Integer.compare(this.last_idx, o.last_idx);
        }

        @Override
        public String toString() {
            String res = idx.size() + " " + idx.toString();
            return res;
        }
    }




    static class Event implements Comparable<Event> {
        int time;
        int type; // start is zero, end is 1

        public Event(int time, int type) {
            this.time = time;
            this.type = type;
        }

        @Override
        public int compareTo(Event o) {
            if (o.time != this.time) {
                return Integer.compare(this.time, o.time);
            }
            return Integer.compare(type, o.type);
        }

    }

    static int minimize_schedule(Day[] days, int n, int m, int k) {
        PriorityQueue<Day> q = new PriorityQueue<Day>(Collections.reverseOrder());
        for (int i = 0; i < n ; ++i) {
            q.add(days[i]);
        }

        int total_hours = Arrays.stream(days).mapToInt(d-> new Integer(d.initial_hours)).sum();
        int hours_saved = 0;
        while (k-- > 0) {
            Day cur = q.poll();
            hours_saved += cur.hours_saved;
            cur.update_day();
            q.add(cur);
        }

        return total_hours - hours_saved;
    }

    static class Day implements Comparable<Day> {
        int day_idx;
        String schedule;
        int hours_saved;
        int initial_hours;

        int start_idx;
        int end_idx;

        public Day(int day_idx, String schedule) {
            this.day_idx = day_idx;
            this.schedule = schedule;

            this.hours_saved = 0;

            this.init_day();
        }

        public void init_day() {
            start_idx = schedule.indexOf('1');
            end_idx = schedule.lastIndexOf('1');

            if (start_idx == -1) {
                initial_hours = 0;
            } else {
                initial_hours = end_idx - start_idx + 1;
            }
            hours_saved = max_saveable_hours();

        }

        public int max_saveable_hours() {
            if (end_idx < start_idx) {
                return 0;
            }
            if (end_idx == start_idx) {
                return 1;
            }
            int s_next = schedule.indexOf('1', 1 + start_idx);
            int e_next = schedule.lastIndexOf('1', end_idx - 1 );
            return Math.max(s_next -start_idx, end_idx - e_next);
        }

        public void update_day() {
            if (start_idx > end_idx) {
                return;
            }

            if (start_idx == end_idx) {
                start_idx++;
                end_idx--;

                hours_saved = max_saveable_hours();
                return;
            }

            int s_next = schedule.indexOf('1', 1 + start_idx);
            int e_next = schedule.lastIndexOf('1', end_idx - 1 );

            if (s_next - start_idx > end_idx - e_next) {
                start_idx = s_next;
            } else {
                end_idx = e_next;
            }
            hours_saved = max_saveable_hours();
        }

        @Override
        public int compareTo(Day o) {
            return Integer.compare(this.hours_saved, o.hours_saved);
        }
    }


    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
       BufferedReader br;
       StringTokenizer st;

       public MyScanner() {
          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;
       }

    }
}