You are fishing with polar bears Alice and Bob. While waiting for the fish to bite, the polar bears get bored. They come up with a game. First Alice and Bob each writes a 01-string (strings that only contain character "0" and "1") a and b. Then you try to turn a into b using two types of operations:

  * Write parity(a) to the end of a. For example, <image>. 
  * Remove the first character of a. For example, <image>. You cannot perform this operation if a is empty. 



You can use as many operations as you want. The problem is, is it possible to turn a into b?

The parity of a 01-string is 1 if there is an odd number of "1"s in the string, and 0 otherwise.

Input

The first line contains the string a and the second line contains the string b (1 ≤ |a|, |b| ≤ 1000). Both strings contain only the characters "0" and "1". Here |x| denotes the length of the string x.

Output

Print "YES" (without quotes) if it is possible to turn a into b, and "NO" (without quotes) otherwise.

Examples

Input

01011
0110


Output

YES


Input

0011
1110


Output

NO

Note

In the first sample, the steps are as follows: 01011 → 1011 → 011 → 0110
import java.io.*;
import java.util.*;
import java.util.zip.ZipEntry;
import java.math.*;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Input in = new Input(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }
}

class Task {
    static final long MOD = 1000000007;
    int[] primes;

    public void solve(int testNumber, Input in, PrintWriter out) {
        char[] a = in.next().toCharArray();
        char[] b = in.next().toCharArray();
        int oneA = 0;
        int oneB = 0;
        for (int i = 0; i < a.length; i++) {
            if (a[i] == '1')
                oneA++;
        }
        for (int i = 0; i < b.length; i++) {
            if (b[i] == '1')
                oneB++;
        }
        if ((oneA & 1) == 1) {
            oneA++;
        }
        if (oneA < oneB)
            out.println("NO");
        else
            out.println("YES");
    }

    // didn't test
    static class BIT {
        int[] MAX;
        int[] MIN;
        int[] SUM;
        int n;

        public BIT(int n) {
            MAX = new int[n + 1];
            MIN = new int[n + 1];
            SUM = new int[n + 1];
            this.n = n;
        }

        public void setSum(int pos, int val) {
            for (int i = pos; i < n; i += (i & -i)) {
                SUM[i] += val;
            }
        }

        public int getSum(int to) {
            int sum = 0;
            for (int i = to; i > 0; i -= (i & -i)) {
                sum += SUM[i];
            }
            return sum;
        }

        public int getSum(int from, int to) {
            return getSum(to) - getSum(from);
        }

        public void setMax(int pos, int val) {
            for (int i = pos; i < n; i += (i & -i)) {
                MAX[i] = Math.max(val, MAX[i]);
            }
        }

        public int getMax(int to) {
            int max = 0;
            for (int i = to; i > 0; i -= (i & -i)) {
                max = Math.max(max, MAX[i]);
            }
            return max;
        }

        public void setMin(int pos, int val) {
            for (int i = pos; i < n; i += (i & -i)) {
                MIN[i] = Math.min(val, MIN[i]);
            }
        }

        public int getMin(int to) {
            int min = 0;
            for (int i = to; i > 0; i -= (i & -i)) {
                min = Math.min(min, MIN[i]);
            }
            return min;
        }

    }

    // didn't test
    static class DisjointSet {
        int[] set;

        public DisjointSet(int n) {
            set = new int[n];
            for (int i = 0; i < n; i++) {
                set[i] = i;
            }
        }

        public int findSet(int a) {
            if (set[a] == a)
                return a;
            return findSet(set[a]);
        }

        public void unionSet(int a, int b) {
            set[findSet(a)] = findSet(b);
        }

        public boolean isSameSet(int a, int b) {
            return findSet(a) == findSet(b);
        }
    }

    static class SegmentTree {
        int[] MAX;
        int[] MIN;
        int[] SUM;
        int[] data;
        int n;

        public SegmentTree(int[] data) {
            this.n = data.length;
            this.data = data;
            MAX = new int[4 * n + 10];
            MIN = new int[4 * n + 10];
            SUM = new int[4 * n + 10];
            buildTree(1, 0, n - 1);
        }

        public int left(int root) {
            return root << 1;
        }

        public int right(int root) {
            return (root << 1) + 1;
        }

        private void buildTree(int root, int rl, int rr) {
            if (rr == rl) {
                MAX[root] = MIN[root] = SUM[root] = data[rr];
            } else {
                int rm = (rl + rr) >> 1;
                buildTree(left(root), rl, rm);
                buildTree(right(root), rm + 1, rr);
                MAX[root] = Math.max(MAX[left(root)], MAX[right(root)]);
                MIN[root] = Math.min(MIN[left(root)], MIN[right(root)]);
                SUM[root] = SUM[left(root)] + SUM[right(root)];
            }
        }

        public int getMax(int from, int to) {
            return getMax(1, 0, n - 1, from, to);
        }

        private int getMax(int root, int rl, int rr, int from, int to) {
            if (from > rr || to < rl || rl > rr) {
                return -1;
            }
            if (from == rl && to == rr) {
                return MAX[root];
            }
            int rm = (rr + rl) >> 1;
            int m1 = getMax(left(root), rl, rm, from, Math.min(to, rm));
            int m2 = getMax(right(root), rm + 1, rr, Math.max(from, rm + 1), to);
            return Math.max(m1, m2);
        }

        public int getMin(int from, int to) {
            return getMin(1, 0, n - 1, from, to);
        }

        private int getMin(int root, int rl, int rr, int from, int to) {
            if (from > rr || to < rl || rl > rr) {
                return Integer.MAX_VALUE;
            }
            if (from == rl && to == rr) {
                return MIN[root];
            }
            int rm = (rr + rl) >> 1;
            int m1 = getMin(left(root), rl, rm, from, Math.min(to, rm));
            int m2 = getMin(right(root), rm + 1, rr, Math.max(from, rm + 1), to);
            return Math.min(m1, m2);
        }

        public int getSum(int from, int to) {
            return getSum(1, 0, n - 1, from, to);
        }

        private int getSum(int root, int rl, int rr, int from, int to) {
            if (from > rr || to < rl || rl > rr) {
                return 0;
            }
            if (from == rl && to == rr) {
                return SUM[root];
            }
            int rm = (rr + rl) >> 1;
            int m1 = getSum(left(root), rl, rm, from, Math.min(to, rm));
            int m2 = getSum(right(root), rm + 1, rr, Math.max(from, rm + 1), to);
            return m1 + m2;
        }
    }

    private String lcs(String s1, String s2) {
        int n = s1.length();
        int m = s2.length();
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        int i = n;
        int j = m;
        while (i > 0 && j > 0) {
            if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                sb.append(s1.charAt(i - 1));
                i--;
                j--;
            } else {
                if (dp[i - 1][j] > dp[i][j - 1]) {
                    i--;
                } else {
                    j--;
                }
            }
        }
        return sb.reverse().toString();
    }

    private boolean isPrime(int n) {
        if (n <= 3)
            return n > 1;
        else if (n % 3 == 0 || n % 2 == 0)
            return false;
        for (long i = 5; i * i <= n; i += 6) {
            if (n % i == 0 || n % (i + 2) == 0)
                return false;
        }
        return true;
    }

    private int[] getPrimes(int n) {
        int len = n + 1;
        boolean[] isPrimes = new boolean[len];
        int[] temps = new int[len];
        int index = 0;
        Arrays.fill(isPrimes, true);
        isPrimes[0] = isPrimes[1] = false;
        for (int i = 2; i * i < len; i++) {
            if (isPrimes[i]) {
                for (int j = i * i; j < len; j += i) {
                    isPrimes[j] = false;
                }
            }
        }
        for (int i = 0; i < len; i++) {
            if (isPrimes[i])
                temps[index++] = i;
        }
        int[] primes = Arrays.copyOf(temps, index);
        return primes;
    }

    static void swap(char[] arrays, int pos1, int pos2) {
        char tmp = arrays[pos1];
        arrays[pos1] = arrays[pos2];
        arrays[pos2] = tmp;
    }

    static void swap(int[] arrays, int pos1, int pos2) {
        int tmp = arrays[pos1];
        arrays[pos1] = arrays[pos2];
        arrays[pos2] = tmp;
    }

    static long modPow(long n, long ex) {
        long res = 1;
        while (ex > 0) {
            if ((ex & 1) == 1)
                res = res * n % MOD;
            n = n * n % MOD;
            ex >>= 1;
        }
        return res;
    }

    static long ModInverse(long n) {
        return modPow(n, MOD - 2);
    }

    static long nCr(int n, int r) {
        if (r > n)
            return -1;
        // return (f[n] * ModInverse((f[r] * f[n - r]) % MOD)) % MOD;
        return 0;
    }
}

class Input {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public Input(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
        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 int nextInt() {
        return Integer.parseInt(next());
    }

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

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}
