import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class String_p {
    public static void main(String[] args) {

        FastReader in = new FastReader();
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        int i,j,a = 0,b,c,n,k,l,m;
        long sum = 0;
        boolean is,was,is1 = false,test=false;
        int[] brr = new int[1];
        int[] arr = new int[1];
        String s,s1;

        s = in.nextLine();
        l = s.length();

        for (i=0; i<l;){

            is = false;
            was = false;
            if (s.charAt(i) == 'h' && i+4 < l){
                i++;
                was = true;
                if (s.charAt(i) == 'e'){
                    i++;
                    if (s.charAt(i) == 'a'){
                        i++;
                        if (s.charAt(i) == 'v'){
                            i++;
                            if (s.charAt(i) == 'y'){
                                is = true;
                                i++;
                            }
                        }
                    }
                }
            }

            if (is){
                is1 = true;
                break;
            }
            if (!was) i++;

        }
       // out.println(i +  " point");
        //mergeSort(arr, 0, 7);
        //Arrays.binarySearch(arr,7);

        for (j=i; j<l;){

            is = false;
            was = false;
            if (s.charAt(j) == 'm' && j+4 < l){
                j++;
                was = true;
                if (s.charAt(j) == 'e'){
                    j++;
                    if (s.charAt(j) == 't'){
                        j++;
                        if (s.charAt(j) == 'a'){
                            j++;
                            if (s.charAt(j) == 'l') {
                                is = true;
                                j++;
                            }
                        }
                    }
                }
            }

            if (is){
                a ++;
            }
            if (!was) j++;
        }
       // out.println(a + " metal_number");

        //  total....heavymetaldfgheavymetal
        for (i=0; i<l;){

            is = false;
            was = false;
            if (s.charAt(i) == 'h' && i+4 < l){
                i++;was = true;
                if (s.charAt(i) == 'e'){
                    i++;
                    if (s.charAt(i) == 'a'){
                        i++;
                        if (s.charAt(i) == 'v'){
                            i++;
                            if (s.charAt(i) == 'y'){
                                is = true;
                                test = true;
                                i++;
                            }
                        }
                    }
                }
            }

            if (is){
                sum += a;
            }

            // matal

            is1 = false;
            if (s.charAt(i) == 'm' && i+4 < l && test){
                i++;
                was = true;
                if (s.charAt(i) == 'e'){
                    i++;
                    if (s.charAt(i) == 't'){
                        i++;
                        if (s.charAt(i) == 'a'){
                            i++;
                            if (s.charAt(i) == 'l') {
                                is1 = true;
                                i++;
                            }
                        }
                    }
                }
            }

            if (is1){
                a --;
            }
            if (!was) i++;

        }

        out.println(sum);
        // metal heavy

        out.flush();

    }

    static void  mergeSort(int arr[], int l, int r)
    {
        if (l < r)
        {
            // Same as (l+r)/2, but avoids overflow for
            // large l and h
            int m = l+(r-l)/2;

            // Sort first and second halves
            mergeSort(arr, l, m);
            mergeSort(arr, m+1, r);

            merge(arr, l, m, r);
        }
    }

    static void merge(int arr[], int l, int m, int r)
    {
        int i, j, k;
        int n1 = m - l + 1;
        int n2 =  r - m;

        /* create temp arrays */
        int L[] = new int[n1],  R[] = new int[n2];

        /* Copy data to temp arrays L[] and R[] */
        for (i = 0; i < n1; i++)
            L[i] = arr[l + i];
        for (j = 0; j < n2; j++)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays back into arr[l..r]*/
        i = 0; // Initial index of first subarray
        j = 0; // Initial index of second subarray
        k = l; // Initial index of merged subarray
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

    /* Copy the remaining elements of L[], if there
       are any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

    /* Copy the remaining elements of R[], if there
       are any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

}


import java.util.*;
import java.io.*;
public class Strings_of_Power
{
	public static void main(String args[]) throws Exception
	{
		BufferedReader f=new BufferedReader(new InputStreamReader(System.in));
		String in=f.readLine();
		int left=0;
		long ans=0;
		while(left<in.length()-4)
		{
			if(in.substring(left,left+5).equals("heavy"))
				for(int x=left+5;x<in.length()-4;x++)
					if(in.substring(x,x+5).equals("metal"))
						ans++;
			left++;
		}
		System.out.println(ans);
	}
}


@file:Suppress("NOTHING_TO_INLINE", "EXPERIMENTAL_FEATURE_WARNING", "OVERRIDE_BY_INLINE")

import java.io.PrintWriter
import java.util.StringTokenizer
import java.util.TreeSet
import kotlin.math.*
import kotlin.random.*
import kotlin.system.exitProcess
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln

/** @author Spheniscine */
fun main() {
    output {
        val A = readIntArray(4)
        val n = A.sum()
        val d = A[0] + A[2] - A[1] - A[3]

        val ans = run ans@ {
            if(abs(d) > 1) return@ans null
            val cnd = IntArray(n)
            if(n and 1 == 0 || d == 1) {
                for(i in 0 until A[0]) {
                    cnd[2*i] = 0
                }
                for(i in A[0] until A[0] + A[2]) {
                    cnd[2*i] = 2
                }
                for(i in 0 until A[1]) {
                    cnd[2*i+1] = 1
                }
                for(i in A[1] until A[1] + A[3]) {
                    cnd[2*i+1] = 3
                }

                if(cnd.check()) return@ans cnd
            }
            if(n and 1 == 0 || d == -1) {
                for(i in 0 until A[0]) {
                    cnd[2*i+1] = 0
                }
                for(i in A[0] until A[0] + A[2]) {
                    cnd[2*i+1] = 2
                }
                for(i in 0 until A[1]) {
                    cnd[2*i] = 1
                }
                for(i in A[1] until A[1] + A[3]) {
                    cnd[2*i] = 3
                }

                if(cnd.check()) return@ans cnd
            }

            null
        }

        if(ans == null) println("NO") else {
            println("YES")
            println(ans.joinToString(" "))
        }
    }
}

fun IntArray.check() = (1 .. lastIndex).all { abs(this[it] - this[it-1]) == 1 }

/** IO code start */
//@JvmField val INPUT = File("input.txt").inputStream()
//@JvmField val OUTPUT = File("output.txt").outputStream()
@JvmField val INPUT = System.`in`
@JvmField val OUTPUT = System.out

@JvmField val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(OUTPUT, false)
inline fun output(block: PrintWriter.() -> Unit) { _writer.apply(block).flush() }

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <R, V> R._shuffle(rnd: Random, get: R.(Int) -> V, set: R.(Int, V) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(0x594E215C123 * System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, IntArray::get, IntArray::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, LongArray::get, LongArray::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, DoubleArray::get, DoubleArray::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, CharArray::get, CharArray::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

fun `please stop removing these imports IntelliJ`() {
    iprintln(max(1, 2))
}


import java.util.*
import kotlin.math.*

fun main() {
    var a = readLine()!!.split(' ').map{ it.toInt() }.toMutableList()
    if (
        a[0] + (if (a[2] > 0 || a[3] > 0) 1 else 0) > a[1] + 1
        || a[3] + (if (a[1] > 0 || a[2] > 0) 1 else 0) > a[2] + 1
        || a[2] > a[1] - a[0] + a[3] + (if (a[3] <= a[2]) 1 else 0)
        || a[1] > a[2] - a[3] + a[0] + (if (a[0] <= a[1]) 1 else 0)
        || abs((a[2] - a[3]) - (a[1] - a[0])) > 1
            ) {
        println("NO")
    } else {
        var deq: Deque<Int> = LinkedList()
        var q = a.sum()
        var start = a.indexOf(a.max())
        deq.addLast(start)
        a[start]--
        while (--q > 0) {
            var minf = deq.first + if (deq.first - 1 >= 0 && a[deq.first - 1] != 0) -1 else if (deq.first + 1 < 4 && a[deq.first + 1] != 0) 1 else 100
            var minl = deq.last + if (deq.last - 1 >= 0 && a[deq.last - 1] != 0) -1 else if (deq.last + 1 < 4 && a[deq.last + 1] != 0) 1 else 100
            var curr = min(minf, minl)
//            println("${ deq.first } ${ deq.last } $minf $minl $curr")
            if (minf > minl) deq.addLast(curr)
            else deq.addFirst(curr)
            a[curr]--
//            println("$deq")
        }
        println("YES")
        for (i in deq.indices) {
            print("${ deq.pop() } ")
        }
    }
}


import java.util.*
import kotlin.math.*

fun main() {
    var a = readLine()!!.split(' ').map{ it.toInt() }.toMutableList()
    if (
        a[0] + (if (a[2] > 0 || a[3] > 0) 1 else 0) > a[1] + 1
        || a[3] + (if (a[1] > 0 || a[0] > 0) 1 else 0) > a[2] + 1
        || a[2] > a[1] - a[0] + a[3] + (if (a[3] <= a[2]) 1 else 0)
        || a[1] > a[2] - a[3] + a[0] + (if (a[0] <= a[1]) 1 else 0)
        || abs((a[2] - a[3]) - (a[1] - a[0])) > 1
            ) {
        println("NO")
    } else {
        var deq: Deque<Int> = LinkedList()
        var q = a.sum()
        var start = a.indexOf(a.max())
        deq.addLast(start)
        a[start]--
        while (--q > 0) {
            var minf = deq.first + if (deq.first - 1 >= 0 && a[deq.first - 1] != 0) -1 else if (deq.first + 1 < 4 && a[deq.first + 1] != 0) 1 else 100
            var minl = deq.last + if (deq.last - 1 >= 0 && a[deq.last - 1] != 0) -1 else if (deq.last + 1 < 4 && a[deq.last + 1] != 0) 1 else 100
            var curr = min(minf, minl)
//            println("${ deq.first } ${ deq.last } $minf $minl $curr")
            if (minf > minl) deq.addLast(curr)
            else deq.addFirst(curr)
            a[curr]--
//            println("$deq")
        }
        println("YES")
        for (i in deq.indices) {
            print("${ deq.pop() } ")
        }
    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.StringTokenizer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class P1265D {

    static boolean multipleIndependent = false;

    final int n = 4;
    int[] remaining;
    int k;
    int[] s;

    void run() {
        remaining = in.nextIntArray(n);
        int sum = IntStream.of(remaining).sum();
        s = new int[sum];
        int pivot = 0;
        while (remaining[pivot] == 0) {
            pivot++;
        }
        s[k] = pivot;
        remaining[pivot]--;
        traverse();
        debug();
        if (k + 1 != sum) {
            flip();
            traverse();
        }
        debug();
        if (k + 1 != sum) {
            out.println("NO");
        } else {
            out.println("YES");
            out.println(
                    IntStream.of(s).mapToObj(String::valueOf)
                            .collect(Collectors.joining(" "))
            );
        }
    }

    void debug() {
        if (1 == 1) {
            return;
        }
        out.println(k);
        out.println(
                IntStream.of(s).mapToObj(String::valueOf)
                        .collect(Collectors.joining(" "))
        );
    }

    void flip() {
        int n = k + 1;
        for (int i = 0; i < n / 2; i++) {
            int tmp = s[i];
            s[i] = s[n - i - 1];
            s[n - i - 1] = tmp;
        }
    }

    void traverse() {
        while (canGoRight()) {
            goRight();
            while (!canGoRight() && canGoleft()) {
                goLeft();
            }
        }
    }

    boolean canGoRight() {
        return s[k] + 1 < n && remaining[s[k] + 1] > 0;
    }

    void goRight() {
        int right = s[k] + 1;
        remaining[right]--;
        s[++k] = right;
    }

    boolean canGoleft() {
        return s[k] - 1 >= 0 && remaining[s[k] - 1] > 0;
    }

    void goLeft() {
        int left = s[k] - 1;
        remaining[left]--;
        s[++k] = left;
    }

    /* -----: Template :----- */
    static InputReader in = new InputReader(System.in);
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static void main(String[] args) {
        int q = multipleIndependent ? in.nextInt() : 1;
        while (q-- > 0) {
            new P1265D().run();
        }
        out.flush();
    }

    static class InputReader {

        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            int bufferSize = 32 * 1024;
            reader = new BufferedReader(new InputStreamReader(stream), bufferSize);
            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 int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public <T> T[] nextIntArrayWithFunction(int n, Function<Integer, T> function, Class<T> c) {
            T[] arr = (T[]) Array.newInstance(c, n);
            for (int i = 0; i < n; i++) {
                arr[i] = function.apply(nextInt());
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public <T> T[] nextLongArrayWithFunction(int n, Function<Long, T> function, Class<T> c) {
            T[] arr = (T[]) Array.newInstance(c, n);
            for (int i = 0; i < n; i++) {
                arr[i] = function.apply(nextLong());
            }
            return arr;
        }

        public int[][] nextIntMap(int n, int m) {
            int[][] map = new int[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = nextIntArray(m);
            }
            return map;
        }

        public long[][] nextLongMap(int n, int m) {
            long[][] map = new long[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = nextLongArray(m);
            }
            return map;
        }

        public char[][] nextCharMap(int n) {
            char[][] map = new char[n][];
            for (int i = 0; i < n; i++) {
                map[i] = next().toCharArray();
            }
            return map;
        }
    }

//    static int numLength(long n) {
//        int l = 0;
//        while (n > 0) {
//            n /= 10;
//            l++;
//        }
//        return l;
//    }
//
//    static <R> long binarySearch(long lowerBound, long upperBound,
//            R value, Function<Long, R> generatorFunction, Comparator<R> comparator) {
//        if (lowerBound <= upperBound) {
//            long mid = (lowerBound + upperBound) / 2;
//            int compare = comparator.compare(generatorFunction.apply(mid), value);
//            if (compare == 0) {
//                return mid;
//            } else if (compare < 0) {
//                return binarySearch(mid + 1, upperBound, value, generatorFunction, comparator);
//            } else {
//                return binarySearch(lowerBound, mid - 1, value, generatorFunction, comparator);
//            }
//        } else {
//            return -1;
//        }
//    }
//
//    static <T> Integer[] sortSimultaneously(T[] key, Comparator<T> comparator,
//            Object[]... moreArrays) {
//        int n = key.length;
//        for (Object[] array : moreArrays) {
//            if (array.length != n) {
//                throw new RuntimeException("Arrays must have equals lengths");
//            }
//        }
//        Integer[] indices = new Integer[n];
//        for (int i = 0; i < n; i++) {
//            indices[i] = i;
//        }
//        Comparator<Integer> delegatingComparator = (a, b) -> {
//            return comparator.compare(key[a], key[b]);
//        };
//        Arrays.sort(indices, delegatingComparator);
//        reorder(indices, key);
//        for (Object[] array : moreArrays) {
//            reorder(indices, array);
//        }
//        return indices;
//    }
//
//    static void reorder(Integer[] indices, Object[] arr) {
//        if (indices.length != arr.length) {
//            throw new RuntimeException("Arrays must have equals lengths");
//        }
//        int n = arr.length;
//        Object[] copy = new Object[n];
//        for (int i = 0; i < n; i++) {
//            copy[i] = arr[indices[i]];
//        }
//        System.arraycopy(copy, 0, arr, 0, n);
//    }
//    static int prodMod(int a, int b, int mod) {
//        return (int) (((long) a) * b % mod);
//    }
//
//    static long prodMod(long a, long b, long mod) {
//        long res = 0;
//        a %= mod;
//        b %= mod;
//        while (b > 0) {
//            if ((b & 1) > 0) {
//                res = (res + a) % mod;
//            }
//            a = (a << 1) % mod;
//            b >>= 1;
//        }
//        return res;
//    }
//
//    static long sumMod(int[] b, long mod) {
//        long res = 0;
//        for (int i = 0; i < b.length; i++) {
//            res = (res + b[i] % mod) % mod;
//        }
//        return res;
//    }
//
//    static long sumMod(long[] a, long mod) {
//        long res = 0;
//        for (int i = 0; i < a.length; i++) {
//            res = (res + a[i] % mod) % mod;
//        }
//        return res;
//    }
//
//    static long sumProdMod(int[] a, long b, long mod) {
//        long res = sumMod(a, mod);
//        return prodMod(res, b, mod);
//    }
//
//    static long sumProdMod(long[] a, long b, long mod) {
//        long res = sumMod(a, mod);
//        return prodMod(res, b, mod);
//    }
//
//    static long sumProdMod(int[] a, int[] b, long mod) {
//        if (a.length != b.length) {
//            throw new RuntimeException("Arrays must have equals lengths");
//        }
//        long res = 0;
//        for (int i = 0; i < a.length; i++) {
//            res = (res + prodMod(a[i], b[i], mod)) % mod;
//        }
//        return res;
//    }
//
//    static long sumProdMod(long[] a, long[] b, long mod) {
//        if (a.length != b.length) {
//            throw new RuntimeException("Arrays must have equals lengths");
//        }
//        long res = 0;
//        for (int i = 0; i < a.length; i++) {
//            res = (res + prodMod(a[i], b[i], mod)) % mod;
//        }
//        return res;
//    }
//
//    static int[] toPrimitive(Integer[] arr) {
//        int[] res = new int[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static int[][] toPrimitive(Integer[][] arr) {
//        int[][] res = new int[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toPrimitive(arr[i]);
//        }
//        return res;
//    }
//
//    static long[] toPrimitive(Long[] arr) {
//        long[] res = new long[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static long[][] toPrimitive(Long[][] arr) {
//        long[][] res = new long[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toPrimitive(arr[i]);
//        }
//        return res;
//    }
//
//    static Integer[] toWrapper(int[] arr) {
//        Integer[] res = new Integer[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static Integer[][] toWrapper(int[][] arr) {
//        Integer[][] res = new Integer[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toWrapper(arr[i]);
//        }
//        return res;
//    }
//
//    static Long[] toWrapper(long[] arr) {
//        Long[] res = new Long[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static Long[][] toWrapper(long[][] arr) {
//        Long[][] res = new Long[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toWrapper(arr[i]);
//        }
//        return res;
//    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.StringTokenizer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class P1265D {

    static boolean multipleIndependent = false;

    final int n = 4;
    int[] remaining;
    int k;
    int[] s;

    void run() {
        remaining = in.nextIntArray(n);
        int sum = IntStream.of(remaining).sum();
        s = new int[sum];
        int pivot = 0;
        while (remaining[pivot] == 0) {
            pivot++;
        }
        s[k] = pivot;
        remaining[pivot]--;
        traverse();
        debug();
        if (k + 1 != sum) {
            flip();
            traverse();
        }
        debug();
        if (k + 1 != sum) {
            out.println("NO");
        } else {
            out.println("YES");
            out.println(
                    IntStream.of(s).mapToObj(String::valueOf)
                            .collect(Collectors.joining(" "))
            );
        }
    }

    void debug() {
        if (1 == 1) {
            return;
        }
        out.println(k);
        out.println(
                IntStream.of(s).mapToObj(String::valueOf)
                        .collect(Collectors.joining(" "))
        );
    }

    void flip() {
        for (int i = 0; i < k / 2; i++) {
            int tmp = s[i];
            s[i] = s[k - i - 1];
            s[k - i - 1] = tmp;
        }
    }

    void traverse() {
        while (canGoRight()) {
            goRight();
            while (!canGoRight() && canGoleft()) {
                goLeft();
            }
        }
    }

    boolean canGoRight() {
        return s[k] + 1 < n && remaining[s[k] + 1] > 0;
    }

    void goRight() {
        int right = s[k] + 1;
        remaining[right]--;
        s[++k] = right;
    }

    boolean canGoleft() {
        return s[k] - 1 >= 0 && remaining[s[k] - 1] > 0;
    }

    void goLeft() {
        int left = s[k] - 1;
        remaining[left]--;
        s[++k] = left;
    }

    /* -----: Template :----- */
    static InputReader in = new InputReader(System.in);
    static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    public static void main(String[] args) {
        int q = multipleIndependent ? in.nextInt() : 1;
        while (q-- > 0) {
            new P1265D().run();
        }
        out.flush();
    }

    static class InputReader {

        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            int bufferSize = 32 * 1024;
            reader = new BufferedReader(new InputStreamReader(stream), bufferSize);
            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 int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public <T> T[] nextIntArrayWithFunction(int n, Function<Integer, T> function, Class<T> c) {
            T[] arr = (T[]) Array.newInstance(c, n);
            for (int i = 0; i < n; i++) {
                arr[i] = function.apply(nextInt());
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public <T> T[] nextLongArrayWithFunction(int n, Function<Long, T> function, Class<T> c) {
            T[] arr = (T[]) Array.newInstance(c, n);
            for (int i = 0; i < n; i++) {
                arr[i] = function.apply(nextLong());
            }
            return arr;
        }

        public int[][] nextIntMap(int n, int m) {
            int[][] map = new int[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = nextIntArray(m);
            }
            return map;
        }

        public long[][] nextLongMap(int n, int m) {
            long[][] map = new long[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = nextLongArray(m);
            }
            return map;
        }

        public char[][] nextCharMap(int n) {
            char[][] map = new char[n][];
            for (int i = 0; i < n; i++) {
                map[i] = next().toCharArray();
            }
            return map;
        }
    }

//    static int numLength(long n) {
//        int l = 0;
//        while (n > 0) {
//            n /= 10;
//            l++;
//        }
//        return l;
//    }
//
//    static <R> long binarySearch(long lowerBound, long upperBound,
//            R value, Function<Long, R> generatorFunction, Comparator<R> comparator) {
//        if (lowerBound <= upperBound) {
//            long mid = (lowerBound + upperBound) / 2;
//            int compare = comparator.compare(generatorFunction.apply(mid), value);
//            if (compare == 0) {
//                return mid;
//            } else if (compare < 0) {
//                return binarySearch(mid + 1, upperBound, value, generatorFunction, comparator);
//            } else {
//                return binarySearch(lowerBound, mid - 1, value, generatorFunction, comparator);
//            }
//        } else {
//            return -1;
//        }
//    }
//
//    static <T> Integer[] sortSimultaneously(T[] key, Comparator<T> comparator,
//            Object[]... moreArrays) {
//        int n = key.length;
//        for (Object[] array : moreArrays) {
//            if (array.length != n) {
//                throw new RuntimeException("Arrays must have equals lengths");
//            }
//        }
//        Integer[] indices = new Integer[n];
//        for (int i = 0; i < n; i++) {
//            indices[i] = i;
//        }
//        Comparator<Integer> delegatingComparator = (a, b) -> {
//            return comparator.compare(key[a], key[b]);
//        };
//        Arrays.sort(indices, delegatingComparator);
//        reorder(indices, key);
//        for (Object[] array : moreArrays) {
//            reorder(indices, array);
//        }
//        return indices;
//    }
//
//    static void reorder(Integer[] indices, Object[] arr) {
//        if (indices.length != arr.length) {
//            throw new RuntimeException("Arrays must have equals lengths");
//        }
//        int n = arr.length;
//        Object[] copy = new Object[n];
//        for (int i = 0; i < n; i++) {
//            copy[i] = arr[indices[i]];
//        }
//        System.arraycopy(copy, 0, arr, 0, n);
//    }
//    static int prodMod(int a, int b, int mod) {
//        return (int) (((long) a) * b % mod);
//    }
//
//    static long prodMod(long a, long b, long mod) {
//        long res = 0;
//        a %= mod;
//        b %= mod;
//        while (b > 0) {
//            if ((b & 1) > 0) {
//                res = (res + a) % mod;
//            }
//            a = (a << 1) % mod;
//            b >>= 1;
//        }
//        return res;
//    }
//
//    static long sumMod(int[] b, long mod) {
//        long res = 0;
//        for (int i = 0; i < b.length; i++) {
//            res = (res + b[i] % mod) % mod;
//        }
//        return res;
//    }
//
//    static long sumMod(long[] a, long mod) {
//        long res = 0;
//        for (int i = 0; i < a.length; i++) {
//            res = (res + a[i] % mod) % mod;
//        }
//        return res;
//    }
//
//    static long sumProdMod(int[] a, long b, long mod) {
//        long res = sumMod(a, mod);
//        return prodMod(res, b, mod);
//    }
//
//    static long sumProdMod(long[] a, long b, long mod) {
//        long res = sumMod(a, mod);
//        return prodMod(res, b, mod);
//    }
//
//    static long sumProdMod(int[] a, int[] b, long mod) {
//        if (a.length != b.length) {
//            throw new RuntimeException("Arrays must have equals lengths");
//        }
//        long res = 0;
//        for (int i = 0; i < a.length; i++) {
//            res = (res + prodMod(a[i], b[i], mod)) % mod;
//        }
//        return res;
//    }
//
//    static long sumProdMod(long[] a, long[] b, long mod) {
//        if (a.length != b.length) {
//            throw new RuntimeException("Arrays must have equals lengths");
//        }
//        long res = 0;
//        for (int i = 0; i < a.length; i++) {
//            res = (res + prodMod(a[i], b[i], mod)) % mod;
//        }
//        return res;
//    }
//
//    static int[] toPrimitive(Integer[] arr) {
//        int[] res = new int[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static int[][] toPrimitive(Integer[][] arr) {
//        int[][] res = new int[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toPrimitive(arr[i]);
//        }
//        return res;
//    }
//
//    static long[] toPrimitive(Long[] arr) {
//        long[] res = new long[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static long[][] toPrimitive(Long[][] arr) {
//        long[][] res = new long[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toPrimitive(arr[i]);
//        }
//        return res;
//    }
//
//    static Integer[] toWrapper(int[] arr) {
//        Integer[] res = new Integer[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static Integer[][] toWrapper(int[][] arr) {
//        Integer[][] res = new Integer[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toWrapper(arr[i]);
//        }
//        return res;
//    }
//
//    static Long[] toWrapper(long[] arr) {
//        Long[] res = new Long[arr.length];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = arr[i];
//        }
//        return res;
//    }
//
//    static Long[][] toWrapper(long[][] arr) {
//        Long[][] res = new Long[arr.length][];
//        for (int i = 0; i < arr.length; i++) {
//            res[i] = toWrapper(arr[i]);
//        }
//        return res;
//    }
}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Codeforces {
    public static void main(String[] args) throws IOException {
        // InputStream inputStream = new FileInputStream("input.txt");
        // OutputStream outputStream = new FileOutputStream("output.txt");
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA {
        long mod = (long)(1000000007);
        long fact[];
        int depth[];
        int parentTable[][];
        int degree[];
        ArrayList<Integer> leaves;
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;

        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            while(testNumber-->0){
                int a = in.nextInt();
                int b = in.nextInt();
                int c = in.nextInt();
                int d = in.nextInt();
                if(a == 0 && b == 0){
                    if(abs(c-d) > 1){
                        out.println("NO");
                        continue;
                    }
                    out.println("YES");
                    int x , y;
                    if(c>d){
                        x = 2;
                        y = 3;
                    }
                    else{
                        x = 3;
                        y = 2;
                    }
                    out.print(x + " ");
                    for(int i=0;i<min(c , d);i++)
                        out.print(y + " " + x + " ");
                    out.println();
                    continue;
                }
                if(c == 0 && d == 0){
                    if(abs(a-b) > 1){
                        out.println("NO");
                        continue;
                    }
                    out.println("YES");
                    int x , y;
                    if(a>b){
                        x = 0;
                        y = 1;
                    }
                    else{
                        x = 1;
                        y = 0;
                    }
                    out.print(x + " ");
                    for(int i=0;i<min(a , b);i++)
                        out.print(y + " " + x + " ");
                    out.println();
                    continue;
                }
                if(a>b || d>c){
                    out.println("NO");
                    continue;
                }
                int leftB = b-a;
                int leftC = c-d;
                int pair = min(leftB , leftC);
                leftB -= pair;
                leftC -= pair;
                if(leftB>1 || leftC>1){
                    out.println("NO");
                    continue;
                }
                out.println("YES");
                ArrayList<Integer>ans = new ArrayList<>();
                if(leftB>0)
                    ans.add(1);
                for(int i=0;i<a;i++){
                    ans.add(0);
                    ans.add(1);
                }
                for(int i=0;i<pair;i++){
                    ans.add(2);
                    ans.add(1);
                }
                for(int i=0;i<d;i++){
                    ans.add(2);
                    ans.add(3);
                }
                if(leftC>0)
                    ans.add(2);
                for(int i:ans)
                    out.print(i + " ");
                out.println();
            }
        }

        class Node{
            char value;
            Node left;
            Node right;
            public Node(char value){
                this.value = value;
                left = null;
                right = null;
            }
        }

        public int[][] multiply(int a[][] , int b[][]){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++)
                        c[i][j] += a[i][k]*b[k][j];
                }
            }
            return c;
        }

        public int[][] multiply(int a[][] , int b[][] , int mod){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++){
                        c[i][j] += a[i][k]*b[k][j];
                        c[i][j]%=mod;
                    }
                }
            }
            return c;
        }

        public int[][] pow(int a[][] , long b){
            int res[][] = new int[a.length][a[0].length];
            for(int i=0;i<a.length;i++)
                res[i][i] = 1;
            while(b>0){
                if((b&1) == 1)
                    res = multiply(res , a , 10);
                a = multiply(a , a , 10);
                b>>=1;
            }
            return res;
        }

        public int distance(ArrayList<ArrayList<Integer>> a , int u , int v){
            return depth[u]+depth[v] - 2*depth[lca(a , u , v)];
        }

        public int lca(ArrayList<ArrayList<Integer>> a , int u , int v){
            if(depth[v]<depth[u]){
                int x = u;
                u = v;
                v = x;
            }
            int diff = depth[v] - depth[u];
            for(int i=0;i<parentTable[v].length;i++){
                // checking whether the ith bit is set in the diff variable
                if(((diff>>i)&1) == 1)
                    v = parentTable[v][i];
            }
            if(v == u)
                return v;
            for(int i=parentTable[v].length-1;i>=0;i--){
                if(parentTable[u][i] != parentTable[v][i]){
                    v = parentTable[v][i];
                    u = parentTable[u][i];
                }
            }
            return parentTable[u][0];
        }

        // for the min max problems
        public void build(int lookup[][] , int arr[], int n) {
            for (int i = 0; i < n; i++)
                lookup[i][0] = arr[i];
            for (int j = 1; (1 << j) <= n; j++) {
                for (int i = 0; (i + (1 << j) - 1) < n; i++) {
                    if (lookup[i][j - 1] > lookup[i + (1 << (j - 1))][j - 1])
                        lookup[i][j] = lookup[i][j - 1];
                    else
                        lookup[i][j] = lookup[i + (1 << (j - 1))][j - 1];
                }
            }
        }
        public int query(int lookup[][] , int L, int R) {
            int j = (int)(Math.log(R - L + 1)/Math.log(2));
            if (lookup[L][j] >= lookup[R - (1 << j) + 1][j])
                return lookup[L][j];
            else
                return lookup[R - (1 << j) + 1][j];
        }

        // for printing purposes
        public void print1d(int a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print1d(long a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print2d(int a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }
        public void print2d(long a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }

        public void sieve(int a[]){
            a[0] = a[1] = 1;
            int i;
            for(i=2;i*i<=a.length;i++){
                if(a[i] != 0)
                    continue;
                a[i] = i;
                for(int k = (i)*(i);k<a.length;k+=i){
                    if(a[k] != 0)
                        continue;
                    a[k] = i;
                }
            }
        }

        public long nCrPFermet(int n , int r , long p){
            if(r==0)
                return 1l;
            // long fact[] = new long[n+1];
            // fact[0] = 1;
            // for(int i=1;i<=n;i++)
            //     fact[i] = (i*fact[i-1])%p;
            long modInverseR = pow(fact[r] , p-2 , p);
            long modInverseNR = pow(fact[n-r] , p-2 , p);
            long w = (((fact[n]*modInverseR)%p)*modInverseNR)%p;
            return w;
        }
        public long pow(long a, long b, long m) {
            a %= m;
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a % m;
                a = a * a % m;
                b >>= 1;
            }
            return res;
        }
        public long pow(long a, long b) {
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a;
                a = a * a;
                b >>= 1;
            }
            return res;
        }
        public void sortedArrayToBST(TreeSet<Integer> a , int start, int end) {
            if (start > end) {
                return;
            }
            int mid = (start + end) / 2;
            a.add(mid);
            sortedArrayToBST(a, start, mid - 1);
            sortedArrayToBST(a, mid + 1, end);
        }
        class Combine{
            int value;
            int delete;
            Combine(int val , int delete){
                this.value = val;
                this.delete = delete;
            }
        }
        class Sort2 implements Comparator<Combine>{
            public int compare(Combine a , Combine b){
                if(a.value > b.value)
                    return 1;
                else if(a.value == b.value && a.delete>b.delete)
                    return 1;
                else if(a.value == b.value && a.delete == b.delete)
                    return 0;
                return -1;
            }
        }
        public int lowerLastBound(ArrayList<Integer> a , int x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>=x)
                return -1;
            if(a.get(r)<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid-1)<x)
                    return mid-1;
                else if(a.get(mid)>=x)
                    r = mid-1;
                else if(a.get(mid)<x && a.get(mid+1)>=x)
                    return mid;
                else if(a.get(mid)<x && a.get(mid+1)<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(ArrayList<Integer> a , Integer x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>x)
                return l;
            if(a.get(r)<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid+1)>x)
                    return mid+1;
                else if(a.get(mid)<=x)
                    l = mid+1;
                else if(a.get(mid)>x && a.get(mid-1)<=x)
                    return mid;
                else if(a.get(mid)>x && a.get(mid-1)>x)
                    r = mid-1;
            }
            return mid;
        }
        public int lowerLastBound(int a[] , int x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>=x)
                return -1;
            if(a[r]<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid-1]<x)
                    return mid-1;
                else if(a[mid]>=x)
                    r = mid-1;
                else if(a[mid]<x && a[mid+1]>=x)
                    return mid;
                else if(a[mid]<x && a[mid+1]<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(long a[] , long x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>x)
                return l;
            if(a[r]<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid+1]>x)
                    return mid+1;
                else if(a[mid]<=x)
                    l = mid+1;
                else if(a[mid]>x && a[mid-1]<=x)
                    return mid;
                else if(a[mid]>x && a[mid-1]>x)
                    r = mid-1;
            }
            return mid;
        }
        public long log(float number , int base){
            return (long) Math.ceil((Math.log(number) / Math.log(base)) + 1e-9);
        }
        public long gcd(long a , long b){
            if(a<b){
                long c = b;
                b = a;
                a = c;
            }
            while(b!=0){
                long c = a;
                a = b;
                b = c%a;
            }
            return a;
        }
        public long[] gcdEx(long p, long q) {
            if (q == 0)
                return new long[] { p, 1, 0 };
            long[] vals = gcdEx(q, p % q);
            long d = vals[0];
            long a = vals[2];
            long b = vals[1] - (p / q) * vals[2];
            // 0->gcd 1->xValue 2->yValue
            return new long[] { d, a, b };
        }
        public void sievePhi(int a[]){
            a[0] = 0;
            a[1] = 1;
            for(int i=2;i<a.length;i++)
                a[i] = i-1;
            for(int i=2;i<a.length;i++)
                for(int j = 2*i;j<a.length;j+=i)
                    a[j] -= a[i];
        }
        public void lcmSum(long a[]){
            int sievePhi[] = new int[(int)1e6 + 1];
            sievePhi(sievePhi);
            a[0] = 0;
            for(int i=1;i<a.length;i++)
                for(int j = i;j<a.length;j+=i)
                    a[j] += (long)i*sievePhi[i];
        }
    }

    static 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 int nextInt() {
            return Integer.parseInt(next());
        }

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

    }
}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Codeforces {
    public static void main(String[] args) throws IOException {
        // InputStream inputStream = new FileInputStream("input.txt");
        // OutputStream outputStream = new FileOutputStream("output.txt");
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA {
        long mod = (long)(1000000007);
        long fact[];
        int depth[];
        int parentTable[][];
        int degree[];
        ArrayList<Integer> leaves;
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;

        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            while(testNumber-->0){
                int a = in.nextInt();
                int b = in.nextInt();
                int c = in.nextInt();
                int d = in.nextInt();
                if(a == 0 && b == 0){
                    if(abs(c-d) > 1){
                        out.println("NO");
                        continue;
                    }
                    out.println("YES");
                    int x , y;
                    if(c>d){
                        x = 2;
                        y = 3;
                    }
                    else{
                        x = 3;
                        y = 2;
                    }
                    if(c!=d)
                        out.print(x + " ");
                    for(int i=0;i<min(c , d);i++)
                        out.print(y + " " + x + " ");
                    out.println();
                    continue;
                }
                if(c == 0 && d == 0){
                    if(abs(a-b) > 1){
                        out.println("NO");
                        continue;
                    }
                    out.println("YES");
                    int x , y;
                    if(a>b){
                        x = 0;
                        y = 1;
                    }
                    else{
                        x = 1;
                        y = 0;
                    }
                    if(a!=b)
                        out.print(x + " ");
                    for(int i=0;i<min(a , b);i++)
                        out.print(y + " " + x + " ");
                    out.println();
                    continue;
                }
                if(a>b || d>c){
                    out.println("NO");
                    continue;
                }
                int leftB = b-a;
                int leftC = c-d;
                int pair = min(leftB , leftC);
                leftB -= pair;
                leftC -= pair;
                if(leftB>1 || leftC>1){
                    out.println("NO");
                    continue;
                }
                out.println("YES");
                ArrayList<Integer>ans = new ArrayList<>();
                if(leftB>0)
                    ans.add(1);
                for(int i=0;i<a;i++){
                    ans.add(0);
                    ans.add(1);
                }
                for(int i=0;i<pair;i++){
                    ans.add(2);
                    ans.add(1);
                }
                for(int i=0;i<d;i++){
                    ans.add(2);
                    ans.add(3);
                }
                if(leftC>0)
                    ans.add(2);
                for(int i:ans)
                    out.print(i + " ");
                out.println();
            }
        }

        class Node{
            char value;
            Node left;
            Node right;
            public Node(char value){
                this.value = value;
                left = null;
                right = null;
            }
        }

        public int[][] multiply(int a[][] , int b[][]){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++)
                        c[i][j] += a[i][k]*b[k][j];
                }
            }
            return c;
        }

        public int[][] multiply(int a[][] , int b[][] , int mod){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++){
                        c[i][j] += a[i][k]*b[k][j];
                        c[i][j]%=mod;
                    }
                }
            }
            return c;
        }

        public int[][] pow(int a[][] , long b){
            int res[][] = new int[a.length][a[0].length];
            for(int i=0;i<a.length;i++)
                res[i][i] = 1;
            while(b>0){
                if((b&1) == 1)
                    res = multiply(res , a , 10);
                a = multiply(a , a , 10);
                b>>=1;
            }
            return res;
        }

        public int distance(ArrayList<ArrayList<Integer>> a , int u , int v){
            return depth[u]+depth[v] - 2*depth[lca(a , u , v)];
        }

        public int lca(ArrayList<ArrayList<Integer>> a , int u , int v){
            if(depth[v]<depth[u]){
                int x = u;
                u = v;
                v = x;
            }
            int diff = depth[v] - depth[u];
            for(int i=0;i<parentTable[v].length;i++){
                // checking whether the ith bit is set in the diff variable
                if(((diff>>i)&1) == 1)
                    v = parentTable[v][i];
            }
            if(v == u)
                return v;
            for(int i=parentTable[v].length-1;i>=0;i--){
                if(parentTable[u][i] != parentTable[v][i]){
                    v = parentTable[v][i];
                    u = parentTable[u][i];
                }
            }
            return parentTable[u][0];
        }

        // for the min max problems
        public void build(int lookup[][] , int arr[], int n) {
            for (int i = 0; i < n; i++)
                lookup[i][0] = arr[i];
            for (int j = 1; (1 << j) <= n; j++) {
                for (int i = 0; (i + (1 << j) - 1) < n; i++) {
                    if (lookup[i][j - 1] > lookup[i + (1 << (j - 1))][j - 1])
                        lookup[i][j] = lookup[i][j - 1];
                    else
                        lookup[i][j] = lookup[i + (1 << (j - 1))][j - 1];
                }
            }
        }
        public int query(int lookup[][] , int L, int R) {
            int j = (int)(Math.log(R - L + 1)/Math.log(2));
            if (lookup[L][j] >= lookup[R - (1 << j) + 1][j])
                return lookup[L][j];
            else
                return lookup[R - (1 << j) + 1][j];
        }

        // for printing purposes
        public void print1d(int a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print1d(long a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print2d(int a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }
        public void print2d(long a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }

        public void sieve(int a[]){
            a[0] = a[1] = 1;
            int i;
            for(i=2;i*i<=a.length;i++){
                if(a[i] != 0)
                    continue;
                a[i] = i;
                for(int k = (i)*(i);k<a.length;k+=i){
                    if(a[k] != 0)
                        continue;
                    a[k] = i;
                }
            }
        }

        public long nCrPFermet(int n , int r , long p){
            if(r==0)
                return 1l;
            // long fact[] = new long[n+1];
            // fact[0] = 1;
            // for(int i=1;i<=n;i++)
            //     fact[i] = (i*fact[i-1])%p;
            long modInverseR = pow(fact[r] , p-2 , p);
            long modInverseNR = pow(fact[n-r] , p-2 , p);
            long w = (((fact[n]*modInverseR)%p)*modInverseNR)%p;
            return w;
        }
        public long pow(long a, long b, long m) {
            a %= m;
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a % m;
                a = a * a % m;
                b >>= 1;
            }
            return res;
        }
        public long pow(long a, long b) {
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a;
                a = a * a;
                b >>= 1;
            }
            return res;
        }
        public void sortedArrayToBST(TreeSet<Integer> a , int start, int end) {
            if (start > end) {
                return;
            }
            int mid = (start + end) / 2;
            a.add(mid);
            sortedArrayToBST(a, start, mid - 1);
            sortedArrayToBST(a, mid + 1, end);
        }
        class Combine{
            int value;
            int delete;
            Combine(int val , int delete){
                this.value = val;
                this.delete = delete;
            }
        }
        class Sort2 implements Comparator<Combine>{
            public int compare(Combine a , Combine b){
                if(a.value > b.value)
                    return 1;
                else if(a.value == b.value && a.delete>b.delete)
                    return 1;
                else if(a.value == b.value && a.delete == b.delete)
                    return 0;
                return -1;
            }
        }
        public int lowerLastBound(ArrayList<Integer> a , int x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>=x)
                return -1;
            if(a.get(r)<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid-1)<x)
                    return mid-1;
                else if(a.get(mid)>=x)
                    r = mid-1;
                else if(a.get(mid)<x && a.get(mid+1)>=x)
                    return mid;
                else if(a.get(mid)<x && a.get(mid+1)<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(ArrayList<Integer> a , Integer x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>x)
                return l;
            if(a.get(r)<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid+1)>x)
                    return mid+1;
                else if(a.get(mid)<=x)
                    l = mid+1;
                else if(a.get(mid)>x && a.get(mid-1)<=x)
                    return mid;
                else if(a.get(mid)>x && a.get(mid-1)>x)
                    r = mid-1;
            }
            return mid;
        }
        public int lowerLastBound(int a[] , int x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>=x)
                return -1;
            if(a[r]<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid-1]<x)
                    return mid-1;
                else if(a[mid]>=x)
                    r = mid-1;
                else if(a[mid]<x && a[mid+1]>=x)
                    return mid;
                else if(a[mid]<x && a[mid+1]<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(long a[] , long x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>x)
                return l;
            if(a[r]<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid+1]>x)
                    return mid+1;
                else if(a[mid]<=x)
                    l = mid+1;
                else if(a[mid]>x && a[mid-1]<=x)
                    return mid;
                else if(a[mid]>x && a[mid-1]>x)
                    r = mid-1;
            }
            return mid;
        }
        public long log(float number , int base){
            return (long) Math.ceil((Math.log(number) / Math.log(base)) + 1e-9);
        }
        public long gcd(long a , long b){
            if(a<b){
                long c = b;
                b = a;
                a = c;
            }
            while(b!=0){
                long c = a;
                a = b;
                b = c%a;
            }
            return a;
        }
        public long[] gcdEx(long p, long q) {
            if (q == 0)
                return new long[] { p, 1, 0 };
            long[] vals = gcdEx(q, p % q);
            long d = vals[0];
            long a = vals[2];
            long b = vals[1] - (p / q) * vals[2];
            // 0->gcd 1->xValue 2->yValue
            return new long[] { d, a, b };
        }
        public void sievePhi(int a[]){
            a[0] = 0;
            a[1] = 1;
            for(int i=2;i<a.length;i++)
                a[i] = i-1;
            for(int i=2;i<a.length;i++)
                for(int j = 2*i;j<a.length;j+=i)
                    a[j] -= a[i];
        }
        public void lcmSum(long a[]){
            int sievePhi[] = new int[(int)1e6 + 1];
            sievePhi(sievePhi);
            a[0] = 0;
            for(int i=1;i<a.length;i++)
                for(int j = i;j<a.length;j+=i)
                    a[j] += (long)i*sievePhi[i];
        }
    }

    static 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 int nextInt() {
            return Integer.parseInt(next());
        }

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

    }
}


import java.io.*;
import java.util.*;
import static java.lang.Math.*;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Codeforces {
    public static void main(String[] args) throws IOException {
        // InputStream inputStream = new FileInputStream("input.txt");
        // OutputStream outputStream = new FileOutputStream("output.txt");
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
    static class TaskA {
        long mod = (long)(1000000007);
        long fact[];
        int depth[];
        int parentTable[][];
        int degree[];
        ArrayList<Integer> leaves;
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;

        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            while(testNumber-->0){
                int a = in.nextInt();
                int b = in.nextInt();
                int c = in.nextInt();
                int d = in.nextInt();
                if(a>b || d>c){
                    out.println("NO");
                    continue;
                }
                int leftB = b-a;
                int leftC = c-d;
                int pair = min(leftB , leftC);
                leftB -= pair;
                leftC -= pair;
                if(leftB>1 || leftC>1){
                    out.println("NO");
                    continue;
                }
                out.println("YES");
                ArrayList<Integer>ans = new ArrayList<>();
                if(leftB>0)
                    ans.add(1);
                for(int i=0;i<a;i++){
                    ans.add(0);
                    ans.add(1);
                }
                for(int i=0;i<pair;i++){
                    ans.add(2);
                    ans.add(1);
                }
                for(int i=0;i<d;i++){
                    ans.add(2);
                    ans.add(3);
                }
                if(leftC>0)
                    ans.add(2);
                for(int i:ans)
                    out.print(i + " ");
                out.println();
            }
        }

        class Node{
            char value;
            Node left;
            Node right;
            public Node(char value){
                this.value = value;
                left = null;
                right = null;
            }
        }

        public int[][] multiply(int a[][] , int b[][]){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++)
                        c[i][j] += a[i][k]*b[k][j];
                }
            }
            return c;
        }

        public int[][] multiply(int a[][] , int b[][] , int mod){
            int c[][] = new int[a.length][b[0].length];
            for(int i=0;i<a.length;i++){
                for(int j=0;j<b[0].length;j++){
                    for(int k=0;k<b.length;k++){
                        c[i][j] += a[i][k]*b[k][j];
                        c[i][j]%=mod;
                    }
                }
            }
            return c;
        }

        public int[][] pow(int a[][] , long b){
            int res[][] = new int[a.length][a[0].length];
            for(int i=0;i<a.length;i++)
                res[i][i] = 1;
            while(b>0){
                if((b&1) == 1)
                    res = multiply(res , a , 10);
                a = multiply(a , a , 10);
                b>>=1;
            }
            return res;
        }

        public int distance(ArrayList<ArrayList<Integer>> a , int u , int v){
            return depth[u]+depth[v] - 2*depth[lca(a , u , v)];
        }

        public int lca(ArrayList<ArrayList<Integer>> a , int u , int v){
            if(depth[v]<depth[u]){
                int x = u;
                u = v;
                v = x;
            }
            int diff = depth[v] - depth[u];
            for(int i=0;i<parentTable[v].length;i++){
                // checking whether the ith bit is set in the diff variable
                if(((diff>>i)&1) == 1)
                    v = parentTable[v][i];
            }
            if(v == u)
                return v;
            for(int i=parentTable[v].length-1;i>=0;i--){
                if(parentTable[u][i] != parentTable[v][i]){
                    v = parentTable[v][i];
                    u = parentTable[u][i];
                }
            }
            return parentTable[u][0];
        }

        // for the min max problems
        public void build(int lookup[][] , int arr[], int n) {
            for (int i = 0; i < n; i++)
                lookup[i][0] = arr[i];
            for (int j = 1; (1 << j) <= n; j++) {
                for (int i = 0; (i + (1 << j) - 1) < n; i++) {
                    if (lookup[i][j - 1] > lookup[i + (1 << (j - 1))][j - 1])
                        lookup[i][j] = lookup[i][j - 1];
                    else
                        lookup[i][j] = lookup[i + (1 << (j - 1))][j - 1];
                }
            }
        }
        public int query(int lookup[][] , int L, int R) {
            int j = (int)(Math.log(R - L + 1)/Math.log(2));
            if (lookup[L][j] >= lookup[R - (1 << j) + 1][j])
                return lookup[L][j];
            else
                return lookup[R - (1 << j) + 1][j];
        }

        // for printing purposes
        public void print1d(int a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print1d(long a[] , PrintWriter out){
            for(int i=0;i<a.length;i++)
                out.print(a[i] + " ");
            out.println();
        }
        public void print2d(int a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }
        public void print2d(long a[][] , PrintWriter out){
            for(int i=0;i<a.length;i++){
                for(int j=0;j<a[i].length;j++)
                    out.print(a[i][j] + " ");
                out.println();
            }
            // out.println();
        }

        public void sieve(int a[]){
            a[0] = a[1] = 1;
            int i;
            for(i=2;i*i<=a.length;i++){
                if(a[i] != 0)
                    continue;
                a[i] = i;
                for(int k = (i)*(i);k<a.length;k+=i){
                    if(a[k] != 0)
                        continue;
                    a[k] = i;
                }
            }
        }

        public long nCrPFermet(int n , int r , long p){
            if(r==0)
                return 1l;
            // long fact[] = new long[n+1];
            // fact[0] = 1;
            // for(int i=1;i<=n;i++)
            //     fact[i] = (i*fact[i-1])%p;
            long modInverseR = pow(fact[r] , p-2 , p);
            long modInverseNR = pow(fact[n-r] , p-2 , p);
            long w = (((fact[n]*modInverseR)%p)*modInverseNR)%p;
            return w;
        }
        public long pow(long a, long b, long m) {
            a %= m;
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a % m;
                a = a * a % m;
                b >>= 1;
            }
            return res;
        }
        public long pow(long a, long b) {
            long res = 1;
            while (b > 0) {
                long x = b&1;
                if (x == 1)
                    res = res * a;
                a = a * a;
                b >>= 1;
            }
            return res;
        }
        public void sortedArrayToBST(TreeSet<Integer> a , int start, int end) {
            if (start > end) {
                return;
            }
            int mid = (start + end) / 2;
            a.add(mid);
            sortedArrayToBST(a, start, mid - 1);
            sortedArrayToBST(a, mid + 1, end);
        }
        class Combine{
            int value;
            int delete;
            Combine(int val , int delete){
                this.value = val;
                this.delete = delete;
            }
        }
        class Sort2 implements Comparator<Combine>{
            public int compare(Combine a , Combine b){
                if(a.value > b.value)
                    return 1;
                else if(a.value == b.value && a.delete>b.delete)
                    return 1;
                else if(a.value == b.value && a.delete == b.delete)
                    return 0;
                return -1;
            }
        }
        public int lowerLastBound(ArrayList<Integer> a , int x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>=x)
                return -1;
            if(a.get(r)<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid-1)<x)
                    return mid-1;
                else if(a.get(mid)>=x)
                    r = mid-1;
                else if(a.get(mid)<x && a.get(mid+1)>=x)
                    return mid;
                else if(a.get(mid)<x && a.get(mid+1)<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(ArrayList<Integer> a , Integer x){
            int l = 0;
            int r = a.size()-1;
            if(a.get(l)>x)
                return l;
            if(a.get(r)<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a.get(mid) == x && a.get(mid+1)>x)
                    return mid+1;
                else if(a.get(mid)<=x)
                    l = mid+1;
                else if(a.get(mid)>x && a.get(mid-1)<=x)
                    return mid;
                else if(a.get(mid)>x && a.get(mid-1)>x)
                    r = mid-1;
            }
            return mid;
        }
        public int lowerLastBound(int a[] , int x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>=x)
                return -1;
            if(a[r]<x)
                return r;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid-1]<x)
                    return mid-1;
                else if(a[mid]>=x)
                    r = mid-1;
                else if(a[mid]<x && a[mid+1]>=x)
                    return mid;
                else if(a[mid]<x && a[mid+1]<x)
                    l = mid+1;
            }
            return mid;
        }
        public int upperFirstBound(long a[] , long x){
            int l = 0;
            int r = a.length-1;
            if(a[l]>x)
                return l;
            if(a[r]<=x)
                return r+1;
            int mid = -1;
            while(l<=r){
                mid = (l+r)/2;
                if(a[mid] == x && a[mid+1]>x)
                    return mid+1;
                else if(a[mid]<=x)
                    l = mid+1;
                else if(a[mid]>x && a[mid-1]<=x)
                    return mid;
                else if(a[mid]>x && a[mid-1]>x)
                    r = mid-1;
            }
            return mid;
        }
        public long log(float number , int base){
            return (long) Math.ceil((Math.log(number) / Math.log(base)) + 1e-9);
        }
        public long gcd(long a , long b){
            if(a<b){
                long c = b;
                b = a;
                a = c;
            }
            while(b!=0){
                long c = a;
                a = b;
                b = c%a;
            }
            return a;
        }
        public long[] gcdEx(long p, long q) {
            if (q == 0)
                return new long[] { p, 1, 0 };
            long[] vals = gcdEx(q, p % q);
            long d = vals[0];
            long a = vals[2];
            long b = vals[1] - (p / q) * vals[2];
            // 0->gcd 1->xValue 2->yValue
            return new long[] { d, a, b };
        }
        public void sievePhi(int a[]){
            a[0] = 0;
            a[1] = 1;
            for(int i=2;i<a.length;i++)
                a[i] = i-1;
            for(int i=2;i<a.length;i++)
                for(int j = 2*i;j<a.length;j+=i)
                    a[j] -= a[i];
        }
        public void lcmSum(long a[]){
            int sievePhi[] = new int[(int)1e6 + 1];
            sievePhi(sievePhi);
            a[0] = 0;
            for(int i=1;i<a.length;i++)
                for(int j = i;j<a.length;j+=i)
                    a[j] += (long)i*sievePhi[i];
        }
    }

    static 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 int nextInt() {
            return Integer.parseInt(next());
        }

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

    }
}


// package com.company;
import java.util.*;
import java.lang.*;
import java.io.*;
//****Use Integer Wrapper Class for Arrays.sort()****
public class BA4 {
    public static void main(String[] Args){
        FastReader scan=new FastReader();
        int a=scan.nextInt();
        int b=scan.nextInt();
        int c=scan.nextInt();
        int d=scan.nextInt();
        StringBuilder ans=new StringBuilder();
//        if(a-b>1||d-c>1){
//            System.out.println("NO");
//        }
//        else if(a>b){
//            if(c!=0&&d!=0) {
//                System.out.println("NO");
//            }
//            else{
//                System.out.println("YES");
//                int co=0;
//                while(a>0||b>0){
//                    if(co%2==0){
//                        ans.append("0 ");
//                        a--;
//                    }
//                    else{
//                        ans.append("1 ");
//                        b--;
//                    }
//                    co++;
//                }
//            }
//            System.out.println(ans);
//        }
//        else if(d>c){
//            if(a!=0&&b!=0) {
//                System.out.println("NO");
//            }
//            else{
//                System.out.println("YES");
//                int co=0;
//                while(c>0||d>0){
//                    if(co%2==0){
//                        ans.append("3 ");
//                        d--;
//                    }
//                    else{
//                        ans.append("2 ");
//                        c--;
//                    }
//                    co++;
//                }
//                System.out.println(ans);
//            }
//        }
//        else{
//            int flag=1;
            int ta=a;
            int tb=b;
            int tc=c;
            int td=d;
            int co=0;
            while(a>0){
                if(co%2==0) {
                    ans.append("0 ");
                    a--;
                }
                else{
                    ans.append("1 ");
                    b--;
                }
                co++;
            }
            co=0;
            if(c>0||d>0){
                ans.append("1 ");
                b--;
                co=1;
            }
            while(b>0){
                if(co%2==0) {
                    ans.append("1 ");
                    b--;
                }
                else{
                    ans.append("2 ");
                    c--;
                }
                co++;
            }
            co=0;
            if(d>0){
                ans.append("2 ");
                c--;
                co=1;
            }
            while(c>0){
                if(co%2==0) {
                    ans.append("2 ");
                    c--;
                }
                else{
                    ans.append("3 ");
                    d--;
                }
                co++;
            }
            if(d>0){
                ans.append("3 ");
                d--;
            }
            if(a==0&&b==0&&c==0&&d==0){
                System.out.println("YES");
                System.out.println(ans);
            }
            else{
                ans=new StringBuilder();
                a=ta;
                b=tb;
                c=tc;
                d=td;
                co=0;
                while(a>0){
                    if(co%2==0) {
                        ans.append("1 ");
                        b--;
                    }
                    else{
                        ans.append("0 ");
                        a--;
                    }
                    co++;
                }
                co=0;
                if(c>0||d>0){
                    ans.append("1 ");
                    b--;
                    co=1;
                }
                while(b>0){
                    if(co%2==0) {
                        ans.append("1 ");
                        b--;
                    }
                    else{
                        ans.append("2 ");
                        c--;
                    }
                    co++;
                }
                co=0;
                if(d>0){
                    ans.append("2 ");
                    c--;
                    co=1;
                }
                while(c>0){
                    if(co%2==0) {
                        ans.append("2 ");
                        c--;
                    }
                    else{
                        ans.append("3 ");
                        d--;
                    }
                    co++;
                }
                if(d>0){
                    ans.append("3 ");
                    d--;
                }
                if(a==0&&b==0&&c==0&&d==0){
                    System.out.println("YES");
                    System.out.println(ans);
                }
                else{
                    ans=new StringBuilder();
                    a=ta;
                    b=tb;
                    c=tc;
                    d=td;
                    co=0;
                    while(d>0){
                        if(co%2==0) {
                            ans.append("2 ");
                            c--;
                        }
                        else{
                            ans.append("3 ");
                            d--;
                        }
                        co++;
                    }
                    co=0;
                    if(b>0||a>0){
                        ans.append("2 ");
                        c--;
                        co=1;
                    }
                    while(c>0){
                        if(co%2==0) {
                            ans.append("2 ");
                            c--;
                        }
                        else{
                            ans.append("1 ");
                            b--;
                        }
                        co++;
                    }
                    co=0;
                    if(a>0){
                        ans.append("1 ");
                        b--;
                        co=1;
                    }
                    while(b>0){
                        if(co%2==0) {
                            ans.append("1 ");
                            b--;
                        }
                        else{
                            ans.append("0 ");
                            a--;
                        }
                        co++;
                    }
                    if(a>0){
                        ans.append("0 ");
                        a--;
                    }
                    if(a==0&&b==0&&c==0&&d==0){
                        System.out.println("YES");
                        System.out.println(ans);
                    }
                    else{
                        ans=new StringBuilder();
                        a=ta;
                        b=tb;
                        c=tc;
                        d=td;
                        co=0;
                        while(d>0){
                            if(co%2==0) {
                                ans.append("3 ");
                                d--;
                            }
                            else{
                                ans.append("2 ");
                                c--;
                            }
                            co++;
                        }
                        co=0;
                        if(b>0||a>0){
                            ans.append("2 ");
                            c--;
                            co=1;
                        }
                        while(c>0){
                            if(co%2==0) {
                                ans.append("2 ");
                                c--;
                            }
                            else{
                                ans.append("1 ");
                                b--;
                            }
                            co++;
                        }
                        co=0;
                        if(a>0){
                            ans.append("1 ");
                            b--;
                            co=1;
                        }
                        while(b>0){
                            if(co%2==0) {
                                ans.append("1 ");
                                b--;
                            }
                            else{
                                ans.append("0 ");
                                a--;
                            }
                            co++;
                        }
                        if(a>0){
                            ans.append("0 ");
                            a--;
                        }
                        if(a==0&&b==0&&c==0&&d==0){
                            System.out.println("YES");
                            System.out.println(ans);
                        }
                        else{
                            System.out.println("NO");
                        }
                    }
                }
            }
//        }
    }
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

}