import java.lang.Integer.min

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    var (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    a -= x
    if (a < 0) {
        println("NO")
        return
    }
    b += a
    b -= y
    if (b < 0) {
        println("NO")
        return
    }
    c += b
    c -= z
    if (c < 0) {
        println("NO")
        return
    }
    println("YES")
}

fun main(args: Array<String>) {
        val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
        var (a, b, c) = readLine()!!.split(" ").map { it.toInt() }

        if(a>=x && a-x+b >= y && a-x+b-y+c >= z ){
            println("YES")
        } else {
            println("NO")
        }
    }

import java.lang.Math.min

fun main(args : Array<String>) {
    val want = IntArray(3)
    val have = IntArray(3)
    for (i in 0 until want.size) {
        want[i] = readInt()
    }
    for (i in 0 until have.size) {
        have[i] = readInt()
    }
    for (i in 0 until want.size) {
        var sum = 0
        for (j in 0 .. i) {
            sum += have[j]
        }
        if (sum < want[i]) {
            println("NO")
            return
        }
        var rest = want[i]
        for (j in 0 .. i) {
            if (rest <= have[j]) {
                have[j] -= rest
                break
            } else {
                rest -= have[j]
                have[j] = 0
            }
        }
    }
    println("YES")
}

private fun readln() = readLine()!!
private fun readlnByte() = readln().toByte()
private fun readlnShort() = readln().toShort()
private fun readlnInt() = readln().toInt()
private fun readlnLong() = readln().toLong()
private fun readlnFloat() = readln().toFloat()
private fun readlnDouble() = readln().toDouble()
private fun readlnBigInt(radix: Int = 10) = readln().toBigInteger(radix)
private fun readlnBigDecimal() = readln().toBigDecimal()

private fun lineSequence(limit: Int = Int.MAX_VALUE) = generateSequence { readLine() }.constrainOnce().take(limit)
private fun readlnStrings() = readln().split(' ')
private fun readlnBytes() = readlnStrings().map { it.toByte() }
private fun readlnShorts() = readlnStrings().map { it.toShort() }
private fun readlnInts() = readlnStrings().map { it.toInt() }
private fun readlnLongs() = readlnStrings().map { it.toLong() }
private fun readlnFloats() = readlnStrings().map { it.toFloat() }
private fun readlnDoubles() = readlnStrings().map { it.toDouble() }

private fun readByteArray() = readlnStrings().run { ByteArray(size) { get(it).toByte() } }
private fun readShortArray() = readlnStrings().run { ShortArray(size) { get(it).toShort() } }
private fun readIntArray() = readlnStrings().run { IntArray(size) { get(it).toInt() } }
private fun readLongArray() = readlnStrings().run { LongArray(size) { get(it).toLong() } }
private fun readFloatArray() = readlnStrings().run { FloatArray(size) { get(it).toFloat() } }
private fun readDoubleArray() = readlnStrings().run { DoubleArray(size) { get(it).toDouble() } }

private fun readlnByteArray(n: Int) = ByteArray(n) { readlnByte() }
private fun readlnShortArray(n: Int) = ShortArray(n) { readlnShort() }
private fun readlnIntArray(n: Int) = IntArray(n) { readlnInt() }
private fun readlnLongArray(n: Int) = LongArray(n) { readlnLong() }
private fun readlnFloatArray(n: Int) = FloatArray(n) { readlnFloat() }
private fun readlnDoubleArray(n: Int) = DoubleArray(n) { readlnDouble() }

private fun readByteArray2d(rows: Int, cols: Int) = Array(rows) { readByteArray().also { require(it.size == cols) } }
private fun readShortArray2d(rows: Int, cols: Int) = Array(rows) { readShortArray().also { require(it.size == cols) } }
private fun readLongArray2d(rows: Int, cols: Int) = Array(rows) { readLongArray().also { require(it.size == cols) } }
private fun readIntArray2d(rows: Int, cols: Int) = Array(rows) { readIntArray().also { require(it.size == cols) } }
private fun readFloatArray2d(rows: Int, cols: Int) = Array(rows) { readFloatArray().also { require(it.size == cols) } }
private fun readDoubleArray2d(rows: Int, cols: Int) = Array(rows) { readDoubleArray().also { require(it.size == cols) } }

private fun isWhiteSpace(c: Char) = c in " \r\n\t"

// JVM-only targeting code follows next

// readString() via sequence is still slightly faster than Scanner
private fun readString() = generateSequence { System.`in`.read().toChar() }
    .dropWhile { isWhiteSpace(it) }.takeWhile { !isWhiteSpace(it) }.joinToString("")
private fun readByte() = readString().toByte()
private fun readShort() = readString().toShort()
private fun readInt() = readString().toInt()
private fun readLong() = readString().toLong()
private fun readFloat() = readString().toFloat()
private fun readDouble() = readString().toDouble()
private fun readBigInt(radix: Int = 10) = readString().toBigInteger(radix)
private fun readBigDecimal() = readString().toBigDecimal()

private fun readBytes(n: Int) = generateSequence { readByte() }.take(n)
private fun readShorts(n: Int) = generateSequence { readShort() }.take(n)
private fun readInts(n: Int) = generateSequence { readInt() }.take(n)
private fun readLongs(n: Int) = generateSequence { readLong() }.take(n)
private fun readFloats(n: Int) = generateSequence { readFloat() }.take(n)
private fun readDoubles(n: Int) = generateSequence { readDouble() }.take(n)

import java.util.Scanner;

fun main() {
    with(Scanner(System.`in`)) {
        var x = nextInt()
        var y = nextInt()
        var z = nextInt()
        var a = nextInt() // green
        var b = nextInt() // purple
        var c = nextInt() // black
        a = a - x
        if (a < 0) {
            println("NO")!!
            return
        }
        if (b >= y) {
            b = b - y
            y = 0
        } else {
            y = y - b
            b = 0
        }
        if (a >= y) {
            a = a - y
            y = 0
        } else {
            y = y - a
            a = 0
        }
        if (y > 0) {
            println("NO")!!
            return
        }
        if (a + b + c >= z) {
            println("YES")!!
        } else {
            println("NO")!!
        }
    }
}

fun main() {
    val targetGrapes = readLine()!!
    val nGrapes = readLine()!!
    println(getGoodString(targetGrapes.split(" "), nGrapes.split(" ")))
}

fun getGoodString(targetGrapes: List<String>, nGrapes: List<String>): String {
    val targetAndrew = targetGrapes[0].toInt()
    val targetDmitry = targetGrapes[1].toInt()
    val targetMichal = targetGrapes[2].toInt()
    var nGreen = nGrapes[0].toInt()
    val nPurple = nGrapes[1].toInt()
    val nBlack = nGrapes[2].toInt()
    if (nGreen < targetAndrew) return "NO"
    nGreen -= targetAndrew
    if (nGreen + nPurple < targetDmitry) return "NO"
    val remaining = nGreen + nPurple + nBlack - targetDmitry
    if (remaining < targetMichal) return "NO"
    return "YES"
}

import kotlin.math.min

fun readThree() = readLine()!!.split(" ").map { it.toInt() }
fun main() {
    var (andrew, dmitry, michal) = readThree()
    var (green, purple, black) = readThree()

    green -= andrew

    if (green < 0) println("NO")
    else {
        val greenForDmitry = min(green, dmitry)
        green -= greenForDmitry
        dmitry -= greenForDmitry

        purple -= dmitry
        when {
            purple < 0 -> println("NO")
            green + purple + black < michal -> println("NO")
            else -> println("YES")
        }
    }
}

fun main(args: Array<String>) {
    var (x,y,z)=readLine()!!.split(" ").map{it.toInt()}
    var (a,b,c)=readLine()!!.split(" ").map{it.toInt()}
    if(a<x)println("NO")
    else{
        a-=x
        if(a+b<y)println("NO")
        else{
            if(a+b-y+c<z)println("NO")
            else println("YES")
        }
    }
}

fun readInt(): Long = readLine()!!.toLong()
fun readInts(): List<Long> = readLine().orEmpty().split(" ").map { it.toLong() }

fun main() {
    val x = readInts().cumsum()
    val y = readInts().cumsum()

    val yes = (x zip y).all { (a, b) -> a <= b }

    println(if (yes) "YES" else "NO")
}

fun <T, R> Iterable<T>.reductions(initial: R, operation: (acc: R, T) -> R): Sequence<R> = sequence {
    var last = initial
    forEach {
        last = operation(last, it)
        yield(last)
    }
}

fun List<Long>.cumsum() = this.reductions(0L) { acc, l -> acc + l }.toList()

private fun readln() = readLine()!!
private fun readlnStrings() = readln().split(' ')
private fun readIntArray() = readlnStrings().run { IntArray(size) { get(it).toInt() } }

fun main(args: Array<String>) {
	val a = readIntArray()
	val b = readIntArray()
	if (a[0] > b[0]) {
		println("NO")
		return
	}
	b[1] += b[0] - a[0]
	if (a[1] > b[1]) {
		println("NO")
		return
	}
	b[2] += b[1] - a[1]
	if (a[2] > b[2]) println("NO")
	else println("YES")
}

private fun readln() = readLine()!!
private fun readlnStrings() = readln().split(' ')
private fun readIntArray() = readlnStrings().run { IntArray(size) { get(it).toInt() } }

fun main(args: Array<String>) {
	val a = readIntArray()
	val b = readIntArray()
	for (i in 0..2) {
		if (a[i] > b[i]) {
			println("NO")
			return
		}
		if (i < 2) b[i+1] += b[i] - a[i]
	}
	println("YES")
}

private fun readLn() = readLine()!!
private fun readStrings() = readLn().split(" ")
private fun readInts() = readStrings().map { it.toInt() }

fun main() {
    val (x, y, z) = readInts()
    val (a, b, c) = readInts()

    println(f(x, y, z, a, b, c))
}

fun f(x: Int, y: Int, z: Int, a: Int, b: Int, c: Int): String {
    var a1 = a
    var y1 = y
    var b1 = b

    if (a1 < x) return "NO"
    a1 -= x

    if (a1 + b1 < y1) return "NO"
    if (a1 < y1) {
        y1 -= a1
        a1 -= a1
        b1 -= y1
    } else {
        a1 -= y1
    }

    return if (a1 + b1 + c < z) "NO" else "YES"
}

import kotlin.math.*

fun read() = readLine()!!
fun getInt() = read().toInt()
fun getInts() = read().split(" ").map(String::toInt)

fun main() {
    var (x, y, z) = getInts()
    var (a, b, c) = getInts()
    var tmp = min(a, x)
    x -= tmp
    a -= tmp
    tmp = min(y, a)
    y -= tmp
    a -= tmp
    tmp = min(y, b)
    y -= tmp
    b -= tmp
    tmp = min(z, a)
    z -= tmp
    a -= tmp
    tmp = min(z, b)
    z -= tmp
    b -= tmp
    tmp = min(z, c)
    z -= tmp
    c -= tmp
    if (x > 0 || y > 0 || z > 0) {
        println("NO")
    } else {
        println("YES")
    }
}

fun main() {
    val a=readInts().toIntArray()
    val b=readInts().toIntArray()
    if (a[0]>b[0]){
        println("NO")
        return
    }
    b[1]+=b[0]-a[0]
    if (a[1]>b[1]) {
        println("NO")
        return
    }
    b[2]+=b[1]-a[1]
    if (a[2]>b[2]) {
        println("NO")
        return
    }
    println("YES")
}

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main() {

    val arr = readInts()
    val arr2 = readInts()

    val x = arr[0] // A - only G
    val y = arr[1] // D - G and F
    val z = arr[2] // M - any

    val a = arr2[0] // G
    val b = arr2[1] // F
    val c = arr2[2] // B

    val overleftAndrey = a - x

    if (overleftAndrey < 0) {
        println("NO")
        return
    }

    val overleftDmitry = (overleftAndrey + b) - y

    if (overleftDmitry < 0) {
        println("NO")
        return
    }

    val overleftMicha = (overleftDmitry + c) - z

    if (overleftMicha < 0) {
        println("NO")
        return
    }

    println("YES")
}

fun readInts() = readLine()!!.split(' ').map { it.toInt() }

import kotlin.system.exitProcess

fun main()
{
    var (x, y, z) = readLine()!!.split(' ').map(String::toInt)

    var (a, b, c) = readLine()!!.split(' ').map(String::toInt)

    if (a < x)
    {
        println("NO")
        exitProcess(0)
    }
    a -= x

    if (a + b < y)
    {
        println("NO")
        exitProcess(0)
    }

    var remaining_grapes = a + b - y + c

    if (remaining_grapes < z)
    {
        println("NO")
        exitProcess(0)
    }

    println("YES")
}

import kotlin.math.min

/**
 * x=a
 * y=a+b
 * z=a+b+c
 */
fun main() {
    var (x, y, z) = readLine()!!.split(' ').map(String::toInt)
    var (a, b, c) = readLine()!!.split(' ').map(String::toInt)

    if (a < x || a + b < y || a + b + c < z) return print("NO")

    // ===== Andrew ===== //

    min(x, a).also {
        x -= it
        a -= it
    }

    if (x != 0) return println("NO")

    // ===== Dmitry ===== //

    min(y, a).also {
        y -= it
        a -= it
    }

    min(y, b).also {
        y -= it
        b -= it
    }

    if (y != 0) return println("NO")

    // ===== Michal ===== //

    min(z, a).also {
        z -= it
        a -= it
    }

    min(z, b).also {
        z -= it
        b -= it
    }

    min(z, c).also {
        z -= it
        c -= it
    }

    if (z != 0) return println("NO")

    println("YES")
}

import java.util.*

fun main() {
    val scanner = Scanner(System.`in`)
    var x = scanner.nextInt()
    var y = scanner.nextInt()
    var z = scanner.nextInt()

    var a = scanner.nextInt()
    var b = scanner.nextInt()
    var c = scanner.nextInt()

    a -= x
    if (a < 0) {
        println("NO")
        return
    }

    if (a > 0) {
        a -= y
        if (a < 0) {
            y = a * -1
        } else {
            y = 0
        }
    }

    b -= y
    if (b < 0) {
        println("NO")
        return
    }

    if (a > 0) {
        a -= z
        if (a < 0) {
            z = a * -1
        } else {
            z = 0
        }
    }

    if (b > 0) {
        b -= z
        if (b < 0) {
            z = b * -1
        } else {
            z = 0
        }
    }

    c -= z
    if (c < 0) {
        println("NO")
        return
    }

    println("YES")
}

import java.lang.Math.abs

fun main() {
    val (a, d, m) = readLine()!!.split(' ').map(String::toInt)
    val (g, v, b) = readLine()!!.split(' ').map(String::toInt)
    print(check(a, d, m, g, v, b))
}

/*1 2 10
10 2 1*/

fun check(a: Int, d: Int, m: Int, g: Int, v: Int, b: Int): String {

    val v1 = v
    val b1 = b
    val a1 = a - g
    var d1 = d
    var m1 = m

    return if (a1 <= 0) {

        d1 -= abs(a1)
        if (d1 <= 0) {

            m1 -= abs(d1) + v1
            return if (m1 <= 0) "YES"
            else {
                m1 -= b1
                if (m1 <= 0) "YES" else "NO"
            }
        } else {
            d1 -= v1
            return if (d1 <= 0) {

                m1 -= abs(d1)
                if (m1 <= 0) "YES"
                else {
                    m1 -= b1
                    if (m1 <= 0) "YES" else "NO"
                }
            } else "NO"
        }
    } else "NO"
}

fun anyGrapes(want:List<String>, grapes:List<String>){
    if(want[0].toInt() - grapes[0].toInt() > 0){
        println("NO")
    }
    else {
        val greenRem = grapes[0].toInt() - want[0].toInt()
        val micha = if((want[2].toInt() - grapes[2].toInt()) < 0){
            0
        }
        else {
            want[2].toInt() - grapes[2].toInt()
        }

        if(greenRem + grapes[1].toInt() >= (micha + want[1].toInt())){
            println("YES")
            return
        }
        println("NO")
    }
}

fun main(args:Array<String>){
    val want = readLine()!!.split(" ")
    val grapes = readLine()!!.split(" ")
    anyGrapes(want, grapes)
}

fun main(args: Array<String>) {
    val n = readLine()!!.split(" ").map(String::toInt)
    val h = readLine()!!.split(" ").map(String::toInt)
    println(if(h[0] >= n[0] && h[0] + h[1] >= n[0] + n[1] && h[0] + h[1] + h[2] >= n[0] + n[1] + n[2]) "YES" else "NO")
}

import java.util.Scanner

val no = "NO"
val yes = "YES"

fun main() {
    val scanner = Scanner(System.`in`)

    val and = scanner.nextInt()
    var dm = scanner.nextInt()
    val mi = scanner.nextInt()

    var green = scanner.nextInt()
    var purple = scanner.nextInt()
    val black = scanner.nextInt()

    if (and > green) {
        println(no)
        return
    }
    green -= and
    if (dm > green + purple) {
        println(no)
        return
    }

    if (dm > green) {
        dm -= green
        green = 0
        purple -= dm
    } else {
        green -= dm
    }

    println(if (green + purple + black >= mi) yes else no)
}

fun good (a: CharArray) : Int {

    for (i in 0..a.size-1) {
        if (a[i] != a[a.size - i - 1])
            return 1
    }
    return 0
}

fun taskC() {
    var t = readLine()!!.toInt()
    while (t--  > 0) {
        var a = readLine()!!.toString()
        var arr = a.toCharArray()
        arr.sort()
        if (good(arr) == 1)
            println(arr.joinToString(""))
        else
            println(-1)
    }
}
fun taskD() {
    var a = readLine()!!.split(" ").map {it.toInt()}
    var b = readLine()!!.split(" ").map {it.toInt()}
    var sum = 0
    for (i in 0..2) {
        sum += b[i]
        if (sum >= a[i]) {
            sum -= a[i]
        }
        else {
            print("NO")
            return
        }
    }
    print("YES")
}

fun main()
{
    taskD()
}
fun taskB() {
    var (a, b, c) = readLine()!!.split(" ").map{it.toInt()}
    var mn = Math.min (a, Math.min (b-1, c-2))
    print(mn + mn + 1 + mn + 2)
}

const val GREEN = 0
const val PURPLE = 1
const val BLACK = 2
const val ANDREW = 0
const val DIMITRY = 1
const val MICHAEL = 2
fun main() {
    val request = readLine()!!.split(" ").map { it.toInt() }
    val box = readLine()!!.split(" ").map { it.toInt() }

    if (request[ANDREW] > box[GREEN])
        print("NO")
    else {
        val leftOfGreen = box[GREEN] - request[ANDREW]

        val leftOfGreenAndPurple = leftOfGreen + box[PURPLE]

        if (leftOfGreenAndPurple < request[DIMITRY]) {
            println("NO")
        } else {

            val sumOfAllLeft = leftOfGreenAndPurple - request[DIMITRY] + box[BLACK]

            if (sumOfAllLeft < request[MICHAEL]) {
                print("NO")
            } else {
                println("YES")
            }

        }

    }

}

fun main(args: Array<String>) {
    val (vA, vD, vM) = readLine()!!.split(' ').map(String::toInt)
    val (v1, v2, v3) = readLine()!!.split(' ').map(String::toInt)

    val o1 = v1 - vA
    if (o1 < 0) {
        println("NO")
        return
    }
    val o12 = v2 + o1 - vD
    if (o12 < 0) {
        println("NO")
        return
    }
    if (o12 + v3<vM){
        println("NO")
    } else  println("YES")
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
	if (x>a || (x+y)>(a+b) || (x+y+z)>(a+b+c)) println("NO") else println("YES")
}

// contest/1171/problem/B Kotlin heroes training done

private fun readLn() = readLine()!!
private fun readInt() = readLn().toInt()
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main() {
    var canDo: Boolean
    val xyz = readInts()
    var (x,y,z) = xyz
    val abc = readInts()
    var (a,b,c) = abc
    if (a < x) {
        canDo = false
    } else {
        a -= x
        if (a+b < y) {
            canDo = false
        } else {
            if (a > y) {
                a -= y
            } else {
                b -= (y-a)
                a = 0
            }
            canDo = (a+b+c) >= z
        }
    }

    println( if (canDo) "YES" else "NO" )
}

import java.lang.System.exit

fun main() {
    val (andrew, dmitry, michal) = readLine()!!.split(' ').map { it.toInt() }
    var (green, purple, black) = readLine()!!.split(' ').map { it.toInt() }
    green-=andrew
    if (green < 0) fail()
    val leftover = green + purple - dmitry
    if (leftover < 0) fail()
    if (leftover + black - michal < 0) fail()
    println("YES")
}

fun fail() {
    println("NO")
    exit(0)
}

import kotlin.system.exitProcess

fun readInts() = readLine()!!.split(" ").map { it.toInt() }

fun main()
{
    var (x, y, z) = readInts()
    var (a, b, c) = readInts()

    if (x > a){
        println("NO")
        exitProcess(0)
    }

    a-=x
    a+=b

    if (a < y){
        println("NO")
        exitProcess(0)
    }

    a-=y
    a+=c

    if (a < z){
        println("NO")
        exitProcess(0)
    }

    println("YES")
}

fun readln() = readLine()!!.trim()
fun readlnInt() = readln().toInt()
fun readlnStrings() = readln().split(' ')
fun readlnInts() = readlnStrings().map { it.toInt() }
fun dbg(x: String) = System.err.println(x)

fun solve(l: List<Int>, l2: List<Int>): String {
	var (x, y, z) = l;
	var (a, b, c) = l2;

	if (x > a) {
		return "NO";
	}
	if (x + y > a + b) {
		return "NO"
	}
	if (x + y + z > a + b + c) {
		return "NO"
	}

	return "YES"
}

fun main(args: Array<String>) {
	var l = readlnInts();
	var l2 = readlnInts();
	var res = solve(l, l2);
	println(res);
}

import java.util.Scanner
 fun bad() {
        println("NO")
        System.exit(0)
    }

    fun main(args: Array<String>) {
        val sc = Scanner(System.`in`)
        val x = sc.nextInt()
        var y = sc.nextInt()
        val z = sc.nextInt()
        var a = sc.nextInt()
        var b = sc.nextInt()
        val c = sc.nextInt()
        a -= x
        if (a < 0)
            bad()
        if (a > y) {
            a -= y
            y = 0
        } else {
            y -= a
            a = 0
            b -= y
            if (b < 0)
                bad()
        }
        if (a + b + c < z)
            bad()
        println("YES")
    }

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map {it.toInt()}
    val (a, b, c) = readLine()!!.split(" ").map {it.toInt()}
    if (x > a) {
        print("NO")
        return
    }
    val r = a - x
    if (y > r + b) {
        print("NO")
        return
    }
    if (z > c + r + b - y) {
        print("NO")
        return
    }
    print("YES")
}

fun main() {
    val require = readLine()!!.split(" ").map { it.toInt() }.toMutableList()
    val exist = readLine()!!.split(" ").map { it.toInt() }.toMutableList()

    when {
        require[0] > exist[0] -> "NO"
        require[1] > exist[0] - require[0] + exist[1] -> "NO"
        require[2] > exist[0] - require[0] + exist[1] - require[1] + exist[2] -> "NO"
        else -> "YES"
    }.run { println(this) }
}

fun main() {
    var (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    var (green, purple, black) = readLine()!!.split(" ").map { it.toInt() }

    var condition = true

    if (!(green >= x && green - x + purple >= y && green - x + purple - y + black >= z)) {
        condition = false
    }

    println(if (condition) "YES" else "NO")
}

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

fun canEat(): Boolean {
    var x = inp.nextInt()
    var y = inp.nextInt()
    var z = inp.nextInt()

    var a = inp.nextInt()
    var b = inp.nextInt()
    var c = inp.nextInt()

    if (a < x) {
        return false
    }
    a -= x
    x = 0

    if (a + b < y) {
        return false
    }
    val remAB = a + b - y
    return remAB + c >= z
}

fun run() {
    val res: String = if (canEat()) "YES" else "NO"
    out.println(res)
}

private val inp = FastInput()
private val out = FastOutput()

fun main() {
    run()
    out.flush()
    out.close()
}

internal class FastInput(private val bufferedReader: BufferedReader) {
    private var tokenizer: StringTokenizer? = null

    constructor() : this(System.`in`)
    constructor(stream: InputStream) : this(BufferedReader(InputStreamReader(stream)))
    constructor(file: File) : this(BufferedReader(FileReader(file)))

    operator fun next(): String {
        while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
            tokenizer = StringTokenizer(bufferedReader.readLine())
        }
        return tokenizer!!.nextToken()
    }

    fun nextInt(): Int = next().toInt()
    fun nextLong(): Long = next().toLong()
}

internal class FastOutput constructor(outputStream: OutputStream = System.out) {
    private val bufferedWriter = BufferedWriter(OutputStreamWriter(outputStream))

    private fun <T> printOne(obj: T) {
        bufferedWriter.write("$obj")
    }

    fun <T> println(obj: T) = bufferedWriter.write("$obj\n")

    fun print(vararg objs: Any) = printd("", *objs)

    fun printd(delimiter: String, vararg objs: Any) {
        for (i in 0 until objs.size) {
            printOne(objs[i])
            printOne(delimiter)
        }
    }

    fun flush() = bufferedWriter.flush()
    fun close() = bufferedWriter.close()
}

import kotlin.system.exitProcess

fun main()
{
    var (x,y,z)= readLine()!!.split(' ').map(String::toInt)
    var (a,b,c)= readLine()!!.split(' ').map(String::toInt)

    a-=x
    if(a<0 || a+b<y)
    {
        print("NO")
        exitProcess(0)
    }
    if(a>=y) a-=y
    else
    {
        y-=a
        a=0
        b-=y
    }
    if(z>a+b+c)
    {
        print("NO")
        exitProcess(0)
    }
    print("YES")
}

fun isEnough(wish: List<Int>, grapes: List<Int>) {
    val enough = grapes[0] >= wish[0] &&
        grapes[0] + grapes[1] >= wish[1] + wish[0] &&
        grapes[0] + grapes[1] + grapes[2] >= wish[2] + wish[0] + wish[1]
    println(when(enough) {
        true -> "YES"
        else -> "NO"
    })
}

fun main() {
    val wish = readLine()!!.split(" ").map { it.toInt() }
    val grapes = readLine()!!.split(" ").map { it.toInt() }

    isEnough(wish, grapes)
}

fun main()
{
    var (x, y, z) = readLine()!!.split(" ").map{it.toInt()};
    var (a, b, c) = readLine()!!.split(" ").map{it.toInt()};
    if (x>a)
        println("NO");
    else
    {
        a-=x;
        if (y>a+b)
            println("NO");
        else
        {
            var tot = a+b+c-y;
            if (z>tot)
                println("NO");
            else
                println("YES");
        }
    }
}

fun main() {
    var (x, y, z) = readLine()!!.split(" ").map{it.toInt()}
    var (a, b, c) = readLine()!!.split(" ").map{it.toInt()}
    if (a < x) {
        println("NO")
        return
    }
    val d = Math.min(y, a - x);
    a -= d + x
    y -= d
    if(b < y) {
        println("NO")
        return
    }
    if(a + b + c >= z + y) {
        println("YES")
    } else {
        println("NO")
    }
}

fun main(){
    val (a,b,c)=readLine()!!.split(" ").map{it.toInt()}
    val (x,y,z)=readLine()!!.split(" ").map{it.toInt()}
    if(x<a||x+y<a+b||x+y+z<a+b+c)println("NO")else println("YES")
}

fun main(args : Array<String>) {

    val NT = 1//readLine()?.toInt() ?: 0

    for(test in 1..NT){
        val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
        val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
        val ok = (a >= x) && (a + b >= x + y) && (a + b + c >= x + y + z)
        println(if(ok)"YES" else "NO")
    }

}

import java.util.Scanner
import java.util.Arrays

fun main(args: Array<String>) {
	val reader = Scanner(System.`in`)

	var x:Int = reader.nextInt()
    	var y:Int = reader.nextInt()
    	var z:Int = reader.nextInt()

    	var g:Int = reader.nextInt()
    	var p:Int = reader.nextInt()
    	var b:Int = reader.nextInt()

	var aux:Int

    	if(g>=x){
		g-=x
		aux=g+p
		if(aux>=y){
			aux-=y
			aux+=b
			if(aux>=z){
				println("YES")
			}
			else{
				println("NO")
			}
		}
		else{
			println("NO")
		}
    	}
	else{
		println("NO")
	}
}

import kotlin.system.exitProcess

fun main(args: Array<String>) {
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    if (a > x) {
        print("NO")
        exitProcess(0)
    }
    if (b <= y + x - a && c + b <= x - a + y + z) {
        print("YES")
    } else {
        print("NO")
    }

}

import java.util.Scanner
import java.util.Arrays
fun main(args:Array<String>){
	val reader = Scanner(System.`in`)
	var t:Int = reader.nextInt()
	var t1:Int = reader.nextInt()
	var t2:Int = reader.nextInt()
	var g:Int = reader.nextInt()
	var g1:Int = reader.nextInt()
	var g2:Int = reader.nextInt()
	if(t<=g){
		g-=t
		if(t1<=g+g1){
			if(t2 <= (g-t1)+g1+g2){
				println("YES")

			} else {
				println("NO")
			}

		} else {
			println("NO")
		}
	} else {
		println("NO")
	}
}

fun main() {
    println(
        if (gotGrapes()) { "YES" } else { "NO" }
    )
}

fun gotGrapes() : Boolean {
    var (andrew, dimitry, michal) = readLine()!!.split(" ").map(String::toInt)
    var (green, purple, black) = readLine()!!.split(" ").map(String::toInt)

    green -= andrew

    if (green < 0) return false

    val g = kotlin.math.min(dimitry, green)
    dimitry -= g
    green -= g
    purple -= dimitry

    if (purple < 0) return false

    return (green + purple + black) >= michal
}

import java.util.Scanner
import java.util.Arrays
fun main(args:Array<String>){
	val reader = Scanner(System.`in`)
	var t:Int = reader.nextInt()
	var t1:Int = reader.nextInt()
	var t2:Int = reader.nextInt()
	var g:Int = reader.nextInt()
	var g1:Int = reader.nextInt()
	var g2:Int = reader.nextInt()
	if(t<=g && t1<=(g-t)+g1 &&t2 <= (g-t1-t)+g1+g2){
		println("YES")
	} else {
		println("NO")
	}
}

import java.util.Scanner
import java.util.Arrays
fun main(args:Array<String>){
	val reader = Scanner(System.`in`)
	var t:Int = reader.nextInt()
	var t1:Int = reader.nextInt()
	var t2:Int = reader.nextInt()
	var g:Int = reader.nextInt()
	var g1:Int = reader.nextInt()
	var g2:Int = reader.nextInt()
	if(t<=g){
		g-=t
		if(t1<=g+g1){
			g-=t1;
			if(g<0){
				g1+=g
				g = 0
			}
			if(t2 <= g+g1+g2){
				println("YES")

			} else {
				println("NO")
			}

		} else {
			println("NO")
		}
	} else {
		println("NO")
	}
}

fun main() {
    var andrew = 0 // -> green
    var dmitry = 0 // -> green or purple
    var michal = 0
    readLine()!!.split(" ").mapIndexed { index, s ->
        when (index) {
            0 -> andrew = s.toInt()
            1 -> dmitry = s.toInt()
            2 -> michal = s.toInt()
        }
    }

    var green = 0
    var purple = 0
    var black = 0
    readLine()!!.split(" ").mapIndexed { index, s ->
        when (index) {
            0 -> green = s.toInt()
            1 -> purple = s.toInt()
            2 -> black = s.toInt()
        }
    }

    green -= andrew

    if (green < 0) {
        println("NO")
    } else {
        green -= dmitry

        if (green < 0) {
            purple -= -green

            if (purple < 0) {
                println("NO")
            } else {
                if (purple + black < michal) {
                    println("NO")
                } else {
                    println("YES")
                }
            }

        } else {
            if (green + purple + black < michal) {
                println("NO")
            } else {
                println("YES")
            }
        }
    }

}

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main() {
    val (x, y, z) = readInts()
    val (a, b, c) = readInts()
    val ok = a >= x && a + b >= x + y && a + b + c >= x + y + z
    println(if (ok) "YES" else "NO")
}

import java.util.*

fun main(args: Array<String>) {

    val reader = Scanner(System.`in`)
    val input1 = reader.nextLine()
    val input2 = reader.nextLine()

    val neededGrapes = input1.split(" ")
    val andrewWants = neededGrapes[0].toInt()
    val dmitryWants = neededGrapes[1].toInt()
    val michalWants = neededGrapes[2].toInt()

    val totalAvailableGrapes = input2.split(" ")

    var totalGreenGrapes = totalAvailableGrapes[0].toInt()
    var totalPurpleGrapes = totalAvailableGrapes[1].toInt()
    var totalBlackGrapes = totalAvailableGrapes[2].toInt()

    if (andrewWants > totalGreenGrapes) {
        println("NO")
        return
    } else {
        totalGreenGrapes -= andrewWants;
    }

    if (dmitryWants > (totalGreenGrapes + totalPurpleGrapes)) {
        println("NO")
        return
    } else {
        totalGreenGrapes -= dmitryWants
        if (totalGreenGrapes < 0) {
            totalPurpleGrapes += totalGreenGrapes
            totalGreenGrapes = 0
        }
    }

    if (michalWants > (totalGreenGrapes + totalPurpleGrapes + totalBlackGrapes)) {
        println("NO")
        return
    }

    println("YES")

}

import kotlin.math.min

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main(args: Array<String>) {
    var (x, y, z) = readInts()
    var (a, b, c) = readInts()
    a -= x
    if (a < 0) {
        println("NO")
        return
    }
    var k = min(b, y)
    y -= k
    b -= k
    k = min(a, y)
    y -= k
    a -= k
    if (y > 0) {
        println("NO")
        return
    }
    k = min(z, a)
    a -= k
    z -= k
    k = min(z, b)
    b -= k
    z -= k
    k = min(z, c)
    c -= k
    z -= k
    if (a < 0 || b < 0 || c < 0 || z > 0) {
        println("NO")
        return
    }
    println("YES")
}

import java.util.Scanner

fun main(args: Array<String>) {
    exercise4()
}

fun exercise4(){
    val reader = Scanner(System.`in`)
    val andrew = reader.nextInt()
    var dimitri = reader.nextInt()
    val michael = reader.nextInt()

    var green = reader.nextInt()
    var purple = reader.nextInt()
    var black = reader.nextInt()

    green -= andrew
    if (green < 0){
        println("NO")
    } else {
        if (green >= dimitri){
            green -= dimitri
            if (green < 0){
                println("NO")
            } else {
                if (green + purple + black >= michael) {
                    println("YES")
                } else {
                    println("NO")
                }
            }
        } else {
            dimitri -= green
            purple -= dimitri
            green = 0
            if (purple < 0){
                println("NO")
            } else {
                if (green + purple + black >= michael) {
                    println("YES")
                } else {
                    println("NO")
                }
            }
        }

    }

}

import java.util.*

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)

    var andrew = sc.nextInt()
    var dimitry = sc.nextInt()
    var michal = sc.nextInt()

    var green = sc.nextInt()
    var purple = sc.nextInt()
    var black = sc.nextInt()

    //Andrew
    if(green >= andrew){
        green -= andrew
        andrew = 0
    }

    //Dimitry
    if(green >= dimitry){
        green -= dimitry
        dimitry = 0
    } else if(dimitry > 0){
        dimitry -= green
        green = 0
    }

    if(purple >= dimitry){
        purple -= dimitry
        dimitry = 0
    } else if(dimitry > 0){
        dimitry -= purple
        purple = 0
    }

    if(green >= michal){
        green -= michal
        michal = 0
    } else if(michal > 0){
        michal -= green
        green = 0
    }

    if(purple >= michal){
        purple -= michal
        michal = 0
    } else if(michal > 0){
        michal -= purple
        purple = 0
    }

    if(black >= michal){
        black -= michal
        michal = 0
    } else if(michal > 0){
        michal -= black
        black = 0
    }

    println(if(andrew == 0 && dimitry == 0 && michal == 0) "YES" else "NO")
}

import java.util.*

fun main() {
    with(Scanner(System.`in`)) {
        val req = nextLine().split(" ").map{ it.toInt() }.toIntArray()
        val grapeCount = nextLine().split(" ").map{ it.toInt() }.toIntArray()

        var remainingGrape = 0
        for (i in 0..2) {
            if (grapeCount[i] + remainingGrape < req[i]) {
                println("NO")
                return
            }
            remainingGrape = grapeCount[i] + remainingGrape - req[i]
        }
        println("YES")
    }
}

import java.io.*
import java.lang.Math.max
import java.lang.Math.min
import java.lang.StringBuilder

fun main(args: Array<String>) {
    val br = BufferedReader(InputStreamReader(System.`in`))
//    val n = br.readLine()!!.toInt()

//    repeat(n)
//    {
        val (x,y,z) = br.readLine()!!.split(' ').map{it.toInt()}
        val (a,b,c) = br.readLine()!!.split(' ').map{it.toInt()}

//        val s = br.readLine()
//        solve1(a)
//        solve2(a,b,c)
//        solve3(s)
        solve4(x,y,z,a,b,c)
//    }

}

fun solve4(x: Int, y: Int, z: Int, a: Int, b: Int, c: Int) {
    // x -> only a
    // y -> not c
    // z -> anything

    val ret = if( a >= x && a - x + b >= y && a - x + b - y + c >= z) "YES" else "NO"
    println(ret)
}

fun solve3(s: String) {

    var ns = s.toCharArray().sorted()
    var sb = StringBuilder()
    for(ch in ns)
    {
        sb.append(ch)
    }
    var nss = sb.toString()

    if(nss.reversed() == nss)
    {
        println(-1)
    }
    else
    {
        println(nss)
    }
}

fun solve2(a: Int, b: Int, c: Int) {

    var m = min(a, b-1)
    m = min(m, c-2)
    println(3 * m + 3)
}

fun solve1(num : Int)
{
    println(num/2)
}

private val inputRegex = """(\d+)\s(\d+)\s(\d+)""".toRegex()

fun main() {
    val (x, y, z) = inputRegex.find(readLine()!!)!!.destructured.toList().map { it.toInt() }
    val (a, b, c) = inputRegex.find(readLine()!!)!!.destructured.toList().map { it.toInt() }

    val result = if (satisfiedCondition(x, y, z, a, b, c)) "YES" else "NO"
    println(result)

}

fun satisfiedCondition(x: Int, y: Int, z: Int, a: Int, b: Int, c: Int): Boolean {
    if (a < x) return false
    if (a + b < x + y) return false
    if (a + b + c < x + y + z) return false

    return true
}

private val inputRegex = """(\d+)\s(\d+)\s(\d+)""".toRegex()

fun main() {
    val (x, y, z) = inputRegex.find(readLine()!!)!!.destructured.toList().map { it.toInt() }
    val (a, b, c) = inputRegex.find(readLine()!!)!!.destructured.toList().map { it.toInt() }

    val result = if (satisfiedCondition(x, y, z, a, b, c)) "YES" else "NO"
    println(result)

}

fun satisfiedCondition(x: Int, y: Int, z: Int, a: Int, b: Int, c: Int): Boolean {
    if (a < x) return false
    val ab = a+b
    val xy = x+y
    if (ab < xy) return false
    if (ab + c < xy + z) return false

    return true
}

fun main() {
    val (x, y, z) = readLine()!!.split(' ').map { it.toInt() }
    val (a, b, c) = readLine()!!.split(' ').map { it.toInt() }
    if (a >= x && a - x + b >= y && a - x + b - y + c >= z) {
        println("YES")
    } else {
        println("NO")
    }
}

fun main() {
    var (x, y, z) = readLine()!!.split(' ').map { it.toInt() }
    var (a, b, c) = readLine()!!.split(' ').map { it.toInt() }

    if (a < x) {
        print("NO")
        return
    } else {
        a -= x
        x = 0
    }

    if (a > 0) {
        if (y > a) {
            y -= a
            a = 0
        } else {
            a -= y
            y = 0
        }
    }

    if (y > 0) {
        if (y > b) {
            print("NO")
            return
        } else {
            b -= y
            y = 0
        }
    }

    if(a > 0){
        if (z > a) {
            z -= a
        } else {
            print("YES")
            return
        }
    }

    if(b > 0){
        if (z > b) {
            z -= b
        } else {
            print("YES")
            return
        }
    }

    if(c > 0){
        if (z > c) {
            print("NO")
            return
        } else {
            print("YES")
            return
        }
    }

    if(x == 0 && y ==0 && z ==0){
        print("YES")
    }else{
        print("NO")
    }
}

/**
 * Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
 */

fun main() {
    val (x,y,z) = readInts()
    val (a,b,c) = readInts()
    val a1 = a - x
    val b1 = b + a1 - y
    val c1 = c + b1 - z
    val res = a1 >= 0 && b1 >= 0 && c1 >= 0
    println(if (res) "YES" else "NO")
}

private fun readInts() = readLine()!!.split(" ").map { it.toInt() }

fun main(args : Array<String>) {
    val (x1, y1, z1) = readLine()!!.split(' ')
    val (g1, p1, b1) = readLine()!!.split(' ')
    var x = x1.toInt()
    var y = y1.toInt()
    var z = z1.toInt()
    var g = g1.toInt()
    var p = p1.toInt()
    var b = b1.toInt()
    var d = 0
    var m = 0

    if(g>=x){
        d = g + p - x
        if(d>=y){
            m = g+p+b-x-y
            if(m>=z){
                println("YES")
            }
            else{
                println("NO")
            }
        }
        else{
            println("NO")
        }

    }
    else{
        println("NO")
    }

}

fun readLn() = readLine()!!
fun readInt() = readLn().toInt()
fun readStrings() = readLn().split(" ")
fun readInts() = readStrings().map(String::toInt)

fun main() {
    val (x, y, z) = readInts()
    val (a, b, c) = readInts()

    if (a < x || a + b < x + y || a + b + c < x + y + z)
        println("NO")
    else
        println("YES")
}

//package com.happypeople.codeforces.c1114

import java.io.ByteArrayInputStream
import java.io.InputStream
import java.util.*

fun main(args: Array<String>) {
    try {
        A1114().run()
    } catch (e: Throwable) {
        println("")
        e.printStackTrace()
    }
}

class A1114 {
    fun run() {
        val sc = Scanner(systemIn())
        val hGreen=sc.nextInt()
        val hNotBlack=sc.nextInt()
        val hAny=sc.nextInt()
        var green=sc.nextInt()
        var purple=sc.nextInt()
        var black=sc.nextInt()

        val m1=hGreen<=green
        green-=hGreen
        val m2=hNotBlack<=green+purple
        val m3=hAny<=green+purple+black-hNotBlack
        val ans =m1 and m2 and m3
        if(ans)
            println("YES")
        else
            println("NO")
    }

    companion object {
        var inputStr: String? = null

        fun systemIn(): InputStream {
            if (inputStr != null)
                return ByteArrayInputStream(inputStr!!.toByteArray())
            else
                return System.`in`
        }

        var printLog = false
        fun log(str: String) {
            if (printLog)
                println(str)
        }
    }
}

import java.util.*

fun main() {

    val sc = Scanner(System.`in`)
    val xyz = IntArray(3)
    val abc = IntArray(3)

    for (i in 0..2) xyz[i] = sc.nextInt()
    for (i in 0..2) abc[i] = sc.nextInt()

    if (abc[0] < xyz[0]) {
        print("NO")
        return
    } else abc[1] += (abc[0] - xyz[0])

    if (abc[1] < xyz[1]) {
        print("NO")
        return
    } else abc[2] += (abc[1] - xyz[1])

    if (abc[2] < xyz[2]) {
        print("NO")
        return
    }

    print("YES")

}

fun main() {
    val needed = readLine()!!.split(' ').map { it.toInt() }
    val available = readLine()!!.split(' ').map { it.toInt() }
    var leftOver = 0
    for (i in 0..2) {
        if (leftOver + available[i] < needed[i]) {
            println("NO")
            return
        } else {
            leftOver = leftOver + available[i] - needed[i]
        }
    }
    println("YES")
}

import java.util.Scanner

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    val x = sc.nextInt()
    val y = sc.nextInt()
    val z = sc.nextInt()
    var a = sc.nextInt()
    var b = sc.nextInt()
    var c = sc.nextInt()
    if (a >= x) {
        a -= x
        b += a
    } else {
        println("NO")
        return
    }

    if (b >= y) {
        b -= y
        c += b
    } else {
        println("NO")
        return
    }

    if (c >= z) {

    } else {
        println("NO")
        return
    }

    println("YES")
}

import java.util.*

fun main(args: Array<String> ) {
    val sc = Scanner(System.`in`)
    val want = IntArray( 3, { sc.nextInt() } )
    val have = IntArray( 3, { sc.nextInt() } )

    for ( i in want.indices.reversed() ) {
        want[i] -= have[i]
        if ( want[i] <= 0 ) continue
        for ( j in i - 1 downTo 0 ) {
            val take = Math.min(want[i], have[j])
            want[i] -= take
            have[j] -= take
        }
        if ( want[i] > 0 ) {
            println( "NO" )
            return
        }
    }
    println( "YES" )
}

fun main(args: Array<String>) {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    var (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    if (a < x) {
        println("NO")
        return
    }
    a -= x
    if (a + b < y) {
        println("NO")
        return
    }
    c += a + b - y
    if (c < z) {
        println("NO")
        return
    }
    println("YES")
}

fun main() {
    val(x,y,z) = readLine()!!.split(" ").map{it.toInt()};
    val(a,b,c) = readLine()!!.split(" ").map{it.toInt()};
    if((a>=x)&&(a+b>=x+y)&&(a+b+c>=x+y+z))
        println("YES");
    else
        println("NO");
}

fun main() {
    fun readInts() = readLine()!!.split(" ").map(String::toInt)

    val (x, y, z) = readInts()
    val (green, purple, black) = readInts()
    print(if (green >= x && green + purple - x >= y && green + purple + black >= x + y + z) "YES" else "NO")
}

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*

fun main() {
    val tokenizer = BufferedReader(InputStreamReader(System.`in`)).use { StringTokenizer(it.readText()) }
    val a = Array(6) { tokenizer.nextInt() }
    if (a[3] >= a[0] && a[3] + a[4] >= a[0] + a[1] && a[3] + a[4] + a[5] >= a[0] + a[1] + a[2])
        println("YES")
    else
        println("NO")
}

fun StringTokenizer.nextInt() = nextToken().toInt()
fun StringTokenizer.nextLong() = nextToken().toLong()

fun main() {
    var str = readLine().toString()
    var arr = str.split(" ").toTypedArray()
    var a = arr[0].toInt()
    var d = arr[1].toInt()
    var m = arr[2].toInt()
    str = readLine().toString()
    arr = str.split(" ").toTypedArray()
    var g = arr[0].toInt()
    var p = arr[1].toInt()
    var b = arr[2].toInt()
    if (((g-a) >= 0) && ((p+g-a-d) >= 0) && ((g+p+b) >= (a+d+m))) {
        println("YES")
    } else {
        println("NO")
    }
}

fun main( )
{
    var (x, y, z) = readLine()!!.split(' ').map(String::toInt)
    var (a, b, c) = readLine()!!.split(' ').map(String::toInt)
    if (a<x)
    {
        println("NO")
    }
    else
    {
        a-=x
        if (a+b<y) println("NO")
        else
        {
            var s = a+b
            s-=y
            s+=c
            if (s<z) println("NO")
            else println("YES")
        }
    }
}

fun main() {
    val (wantA, wantB, wantC) = readLine()!!.split(" ").map(String::toInt)
    val (green, purple, black) = readLine()!!.split(" ").map(String::toInt)

    val forA = minOf(wantA, green)
    val forB = minOf(wantB, green + purple - forA)
    val forC = minOf(wantC, green + black + purple - forA - forB)

    if (wantA == forA && wantB == forB && wantC == forC)
        println("YES")
    else
        println("NO")
}

import java.util.*

//2019-03-02
fun main(args: Array<String>) = with(Scanner(System.`in`)) {
  val x = nextInt()
  val y = nextInt()
  val z = nextInt()

  val a = nextInt()
  val b = nextInt()
  val c = nextInt()

  val greenDiff = a - x
  if (greenDiff < 0) {
    print("NO")
    return@with
  }

  val purpleDiff = greenDiff + b - y
  if (purpleDiff < 0) {
    print("NO")
    return@with
  }

  val blackDiff = purpleDiff + c - z
  if (blackDiff < 0) {
    print("NO")
    return@with
  }

  print("YES")
}

import java.util.*

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)

    var andrew = sc.nextInt()
    var dimitry = sc.nextInt()
    var michal = sc.nextInt()

    var green = sc.nextInt()
    var purple = sc.nextInt()
    var black = sc.nextInt()

    if(green > andrew){
        green -= andrew
        andrew = 0
    }

    if(green > dimitry){
        green -= dimitry
        dimitry = 0
    } else {
        dimitry -= green
        green = 0
    }

    if(purple > dimitry){
        purple -= dimitry
        dimitry = 0
    } else {
        dimitry -= purple
        purple = 0
    }

    if(green > michal){
        green -= michal
        michal = 0
    } else {
        michal -= green
        green = 0
    }

    if(purple > michal){
        purple -= michal
        michal = 0
    } else {
        michal -= purple
        purple = 0
    }

    if(black > michal){
        black -= michal
        michal = 0
    } else {
        michal -= black
        green = 0
    }

    println(if(andrew == 0 && dimitry == 0 && michal == 0) "YES" else "NO")
}

fun main(args: Array<String>) {

    val (an, dm, mh) = readLine()!!
            .split(" ")
            .map { Integer.valueOf(it)!! }

    var (green, purple, black) = readLine()!!
            .split(" ")
            .map { Integer.valueOf(it)!! }
    if (green < an) {
        no()
        return
    } else {
        green -= an
    }

    if (green + purple < dm) {
        no()
        return
    }

    if (green + purple + black - dm - mh > 0) {
        println("YES")
    } else {
        no()
    }
}

fun no() {
    println("NO")
}

fun main()
{
    var (x, y, z) = readLine()!!.split(" ").map{it.toInt()};
    var (a, b, c) = readLine()!!.split(" ").map{it.toInt()};
    if (x>a)
        println("NO");
    else
    {
        a-=x;
        if (y>a+c)
            println("NO");
        else
        {
            var tot = a+b+c-y;
            if (z>tot)
                println("NO");
            else
                println("YES");
        }
    }
}

fun main() {
    val (x, y, z) = readLine()!!.split(' ').map(String::toInt)
    val (green, purple, black) = readLine()!!.split(' ').map(String::toInt)

    if (x <= green && y <= green+purple && z <= green+purple+black)
        print("YES")
    else
        print("NO")
}

fun solve(x:Int, y:Int, z:Int, a:Int, b:Int, c:Int):Int {
	if (x > a || x+y > a+b+c || x+y+z > a+b+c)
		return 1
	else
		return 0
}

fun main() {
	val (x, y, z) = readLine()!!.split(' ').map(String::toInt)
	val (a, b, c) = readLine()!!.split(' ').map(String::toInt)
	val ans = solve(x, y, z, a, b, c);
	print(arrayOf("YES", "NO")[ans])
}

import java.util.Scanner

val no = "NO"
val yes = "YES"

fun main() {
    val scanner = Scanner(System.`in`)

    val and = scanner.nextInt()
    var dm = scanner.nextInt()
    val mi = scanner.nextInt()

    var green = scanner.nextInt()
    var purple = scanner.nextInt()
    val black = scanner.nextInt()

    if (and > green) {
        println(no)
        return
    }
    green -= and
    if (dm > green + purple) {
        println(no)
        return
    }

    if (green >= dm) {
        green -= dm
    } else {
        dm -= green
        green = 0
        purple -= dm
    }

    println(if (green + purple + black > mi) yes else no)
}

import kotlin.math.max
import kotlin.math.min

fun main() {
    val xyz = readLine()!!.split(' ')
    val abc = readLine()!!.split(' ')

    val x = xyz[0].toInt() // only a
    val y = xyz[1].toInt() // not c
    val z = xyz[2].toInt() // any

    val a = abc[0].toInt()
    val b = abc[1].toInt()
    val c = abc[2].toInt()

    val a0 = a - x

    if (a0 < 0) {
        println("NO")
        return
    }

    val y0 = max(a0 - y, 0)
    val a1 = a0 - y0
    val b0 = b - (y - y0)

    if (b0 < 0) {
        println("NO")
        return
    }

    val c0 = (a1 + b0 + c) - z

    if (c0 < 0) {
        println("NO")
        return
    }

    println("YES")
}

import java.util.Scanner

val no = "NO"
val yes = "YES"

fun main() {
    val scanner = Scanner(System.`in`)

    val and = scanner.nextInt()
    var dm = scanner.nextInt()
    val mi = scanner.nextInt()

    var green = scanner.nextInt()
    var purple = scanner.nextInt()
    val black = scanner.nextInt()

    if (and >= green) {
        println(no)
        return
    }
    green -= and
    if (dm >= green + purple) {
        println(no)
        return
    }

    if (green >= dm) {
        green -= dm
    } else {
        dm -= green
        green = 0
        purple -= dm
    }

    println(if (green + purple + black >= mi) yes else no)
}

import java.io.*
import java.lang.Math.max
import java.lang.Math.min
import java.lang.StringBuilder

fun main(args: Array<String>) {
    val br = BufferedReader(InputStreamReader(System.`in`))
//    val n = br.readLine()!!.toInt()

//    repeat(n)
//    {
        val (x,y,z) = br.readLine()!!.split(' ').map{it.toInt()}
        val (a,b,c) = br.readLine()!!.split(' ').map{it.toInt()}

//        val s = br.readLine()
//        solve1(a)
//        solve2(a,b,c)
//        solve3(s)
        solve4(x,y,z,a,b,c)
//    }

}

fun solve4(x: Int, y: Int, z: Int, a: Int, b: Int, c: Int) {
    // x -> only a
    // y -> not c
    // z -> anything

    var ret = "YES"

    if(x > a)
    {
        ret = "NO"
    }
    else
    {
        var newa = a - x

        var newz = max( z - c, 0)

        var newc = if(z < c) c - z else 0

        val left = b + newa + newc

        if(y + newz > left) ret = "NO"
    }

    println(ret)
}

fun solve3(s: String) {

    var ns = s.toCharArray().sorted()
    var sb = StringBuilder()
    for(ch in ns)
    {
        sb.append(ch)
    }
    var nss = sb.toString()

    if(nss.reversed() == nss)
    {
        println(-1)
    }
    else
    {
        println(nss)
    }
}

fun solve2(a: Int, b: Int, c: Int) {

    var m = min(a, b-1)
    m = min(m, c-2)
    println(3 * m + 3)
}

fun solve1(num : Int)
{
    println(num/2)
}

fun main(args: Array<String>) {
    val parts = readLine()!!.toString().split(" ")
    val A : Int =parts.get(0).toInt()
    val D : Int= parts.get(1).toInt()
    val M : Int = parts.get(2).toInt()

    val grappe = readLine()!!.toString().split(" ")
    val G : Int =grappe.get(0).toInt()
    val P : Int= grappe.get(1).toInt()
    val B : Int = grappe.get(2).toInt()

    var res : String ="YES"

    val restG = G - A

    if(restG<0){
        res = "NO"
    }else{

        val restPG = D - (restG + P)
        if( restPG < 0){
            res = "NO"
        }else{
            val restPGD = M - restPG
            if(restPGD < 0 ){
                    res = "NO"
            }
        }

    }

    println("$res")
}

fun anyGrapes(want:List<String>, grapes:List<String>){
    if(want[0].toInt() > grapes[0].toInt()){
        println("NO")
    }
    else {
        val dymiCurr = want[1].toInt()
        val michCurr = want[2].toInt() - grapes[2].toInt() //Michael gets all black grapes
        val remainGrPu = (grapes[0].toInt() + grapes[1].toInt()) - (want[0].toInt()) //remaining green and purple grapes

        if (((dymiCurr+michCurr) - remainGrPu) > 0){
            println("NO")
            return
        }
        println("YES")
    }
}

fun main(args:Array<String>){
    val want = readLine()!!.split(" ")
    val grapes = readLine()!!.split(" ")
    anyGrapes(want, grapes)
}

// contest/1171/problem/B Kotlin heroes training done

private fun readLn() = readLine()!!
private fun readInt() = readLn().toInt()
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main() {
    var canDo: Boolean
    val xyz = readInts()
    var (x,y,z) = xyz
    val abc = readInts()
    var (a,b,c) = abc
    if (a < x) {
        canDo = false
    } else {
        a -= x
        if (a+b < y) {
            canDo = false
        } else {
            if (a > y) {
                y -= a
            } else {
                b -= (y-a)
                a = 0
            }
            canDo = (a+b+c) >= z
        }
    }

    println( if (canDo) "YES" else "NO" )
}

import kotlin.math.min

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main(args: Array<String>) {
    var (x, y, z) = readInts()
    var (a, b, c) = readInts()
    a -= x
    if (a < 0) {
        println("NO")
        return
    }
    var k = min(a, y)
    y -= k
    a -= k
    if (y > 0) {
        c -= y
    }
    k = min(z, a)
    a -= k
    z -= k
    k = min(z, b)
    b -= k
    z -= k
    k = min(z, c)
    c -= k
    z -= k
    if (a < 0 || b < 0 || c < 0 || z > 0) {
        println("NO")
        return
    }
    println("YES")
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map(String::toInt)
    val (a, b, c) = readLine()!!.split(" ").map(String::toInt)
    if (a >= x && a + b >= x + y && a + c + c >= x + y + z) print("YES") else print("NO")
}

import java.util.*

fun main(args: Array<String> ) {
    val sc = Scanner(System.`in`)
    val want = IntArray( 3, { sc.nextInt() } )
    val have = IntArray( 3, { sc.nextInt() } )

    for ( i in want.indices.reversed() ) {
        want[i] -= have[i]
        if ( want[i] <= 0 ) continue
        for ( j in i - 1 downTo 0 ) {
            want[i] -= Math.min( want[i], have[j] )
        }
        if ( want[i] > 0 ) {
            println( "NO" )
            return
        }
    }
    println( "YES" )
}

  fun main(args:Array<String>){
    val (a, b, c) = readLine()!!.split(' ')
    var x1:Int = a.toInt()
    var y1:Int = b.toInt()
    var z1:Int = c.toInt()
    val (a1, b1, c1) = readLine()!!.split(' ')
    var x:Int = a1.toInt()
    var y:Int = b1.toInt()
    var z:Int = c1.toInt()
    var flag = 0
    if(x1 <= x && flag == 0) {x -= x1}
    else {flag = 1}

    if(y1 <= (y + x) && flag == 0)
        {if(y1 <= y) y -= y1
        else y = 0; x -= (y - y1)}
    else {flag = 1}

    if(z1 <= (x + y + z) && flag == 0) {flag = 0}
    else {flag = 1}

    if(flag == 0) {println("YES")}
    else {println("NO")}
}

import java.util.*

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main(args: Array<String>) {

    var(x,y,z) =readInts()
    var(green,purple,black) =readInts()

    var temp:Int

    temp=green-x
    if(temp<0){
        println("NO")
        return
    }else{
        green-x
    }
    temp=(green+purple)-y
    if(temp<0){
        println("NO")
        return
    }else{
        val purp=y-green
        val gre=y-purple
        green-gre
        purple-purp
    }

    temp=(green+purple+black)-z

    if(temp<0){
        println("NO")
        return
    }
    println("YES")

}

fun main() {
    val targetGrapes = readLine()!!
    val nGrapes = readLine()!!
    println(getGoodString(targetGrapes.split(" "), nGrapes.split(" ")))
}

fun getGoodString(targetGrapes: List<String>, nGrapes: List<String>): String {
    val targetAndrew = targetGrapes[0].toInt()
    val targetDmitry = targetGrapes[1].toInt()
    val targetMichael = targetGrapes[2].toInt()
    var nGreen = nGrapes[0].toInt()
    val nPurple = nGrapes[1].toInt()
    val nBlack = nGrapes[2].toInt()
    if (nGreen < targetAndrew) return "NO"
    nGreen -= targetAndrew
    if (nGreen + nPurple < targetDmitry) return "NO"
    val remaining = nGreen + nPurple + nBlack - targetDmitry
    if (remaining < targetMichael) return "YES"
    return "NO"
}

fun main() {
    val want = readLine()!!.split(" ").map{it.toInt()}
    val box  = readLine()!!.split(" ").map{it.toInt()}

    if (box[0]<want[0]) println("NO")
    else if((box[0] - want[0] + box[1]) < want[1]) println("NO")
    else if ((box[0] - want[0] + box[1] - want[1]) < want[2]) println("NO")
    else println("YES")
}

private fun readLn() = readLine()!!
private fun readStrings() = readLn().split(" ")
private fun readInts() = readStrings().map { it.toInt() }

fun main() {
    val (x, y, z) = readInts()
    val (a, b, c) = readInts()

    println(f(x, y, z, a, b, c))
}

fun f(x: Int, y: Int, z: Int, a: Int, b: Int, c: Int): String {
    var a1 = a
    var y1 = y
    var b1 = b

    if (a1 < x) return "NO"
    a1 -= x

    if (a1 + b1 < y1) return "NO"
    if (a1 < y1) {
        y1 -= a
        a1 -= a1
        b1 -= y1
    } else {
        a1 -= y1
    }

    return if (a1 + b + c < z) "NO" else "YES"
}

import java.util.Scanner;

fun main() {
    with(Scanner(System.`in`)) {
        var x = nextInt()
        var y = nextInt()
        var z = nextInt()
        var a = nextInt() // green
        var b = nextInt() // purple
        var c = nextInt() // black
        a = a - x
        if (a < 0) {
            println("NO")!!
            return
        }
        if (b >= y) {
            b = b - y
            y = 0
        } else {
            y = y - b
            b = 0
        }
        if (c >= y) {
            c = c - y
            y = 0
        } else {
            y = y - c
            c = 0
        }
        if (y > 0) {
            println("NO")!!
            return
        }
        if (a + b + c >= z) {
            println("YES")!!
        } else {
            println("NO")!!
        }
    }
}

import java.util.Scanner

fun main(args: Array<String>) {
    exercise4()
}

fun exercise4(){
    val reader = Scanner(System.`in`)
    val andrew = reader.nextInt()
    var dimitri = reader.nextInt()
    val michael = reader.nextInt()

    var green = reader.nextInt()
    var purple = reader.nextInt()
    var black = reader.nextInt()

    green -= andrew
    if (green < 0){
        println("NO")
    } else {
        if (green >= dimitri){
            green -= dimitri
        } else {
            dimitri -= green
            purple -= dimitri
            green = 0
            if (purple < 0){
                println("NO")
            } else {
                if (green + purple + black >= michael) {
                    println("YES")
                } else {
                    println("NO")
                }
            }
        }
    }

}

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main() {
    val (x, y, z) = readInts() // num they want to eat
    val (g, p, b) = readInts()

    // x will only eat greens
    // y will only eat green or black
    // z eats all

    var greens = g
    greens -= x // x eats the green grapes he wants
    var notBlack = greens + p
    notBlack -= y
    var rest = greens + notBlack + b
    rest -= z

    if (greens >= 0 && notBlack >= 0 && rest >= 0)
        println("YES")
    else
        println("NO")
}

fun main() {
    val (x, y, z) = readLine()!!.split(' ').map(String::toInt)
    val (green, purple, black) = readLine()!!.split(' ').map(String::toInt)

    if (x <= green && y <= green+purple && z <= green+purple+black)
        print("YES")
    else
        print("NO")
}

fun main(args: Array<String>) {
    val (andrew, dmitry, mischal) = readLine()!!.map { it.toInt() }
    val (green, purple, black) = readLine()!!.map { it.toInt() }

    if (green < andrew) {
        println("NO")
        return
    }
    val remainGreen = green - andrew
    if (remainGreen + purple < dmitry) {
        println("NO")
        return
    }
    val remain = remainGreen + purple - andrew
    if (remain + black < mischal) {
        println("NO")
        return
    }
    println("YES")
}

import kotlin.system.exitProcess

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main() {
    var (x, y, z) = readInts()
    var (a, b, c) = readInts()
    if (x+y+z>a+b+c || x>a || y>a-x+c) {
        println("NO")
    } else {
        println("YES")
    }
}

import java.util.*

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main(args: Array<String>) {

    var(x,y,z) =readInts()
    var(green,purple,black) =readInts()

    var temp:Int

    temp=green-x
    if(temp<0){
        println("NO")
        return
    }
    temp=(green+purple)-y
    if(temp<0){
        println("NO")
        return
    }

    temp=(green+purple+black)-z

    if(temp<0){
        println("NO")
        return
    }

    println("YES")

}

fun isEnough(wish: List<Int>, grapes: List<Int>) {
    val enough = grapes[0] >= wish[0] &&
        grapes[0] + grapes[1] >= wish[1] &&
        grapes[0] + grapes[1] + grapes[2] >= wish[2]
    println(when(enough) {
        true -> "YES"
        else -> "NO"
    })
}

fun main() {
    val wish = readLine()!!.split(" ").map { it.toInt() }
    val grapes = readLine()!!.split(" ").map { it.toInt() }

    isEnough(wish, grapes)
}

fun main() {
    val r = System.`in`.bufferedReader()
    val s = StringBuilder()
    //val n = r.readLine()!!.toInt()
    //var (n, m) = r.readLine()!!.split(" ").map { it.toInt() }
    val (x, y, z) = r.readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = r.readLine()!!.split(" ").map { it.toInt() }
    val ans = a>=x&&(x-a+b>=y)&&(x+y-a-b+c>=z)
    println(if (ans)"YES" else "NO")
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    if (x>a) println("NO")
    if (x+y>a+b) println("NO")
    if (x+y+z>a+b+c) println("NO") else println("YES")
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }

    val grapesMap = mutableMapOf(
        "green" to a,
        "purple" to b,
        "black" to c
    )

    provideAndrew(grapesMap, x)
    provideDmitri(grapesMap, y)
    provideMichal(grapesMap, z)
    if (isValidDistribution(grapesMap)) println("YES") else println("NO")
}

private fun provideAndrew(grapesMap: MutableMap<String, Int>, wanted: Int) {
    grapesMap["green"] = grapesMap["green"]!!.minus(wanted)
}

private fun provideDmitri(grapesMap: MutableMap<String, Int>, wanted: Int) {
    val purple = grapesMap["purple"]!!
    if (wanted <= purple) {
        grapesMap["purple"] = purple.minus(wanted)
        return
    }
    grapesMap["purple"] = 0
    grapesMap["green"] = grapesMap["green"]!!.minus(wanted - purple)
}

private fun provideMichal(grapesMap: MutableMap<String, Int>, wanted: Int) {
    grapesMap["black"] = grapesMap["black"]!!.minus(wanted)
}

private fun isValidDistribution(grapesMap: MutableMap<String, Int>): Boolean {
    return grapesMap.filter { it.value >= 0 }.size == grapesMap.size
}

import java.util.*

fun main(args: Array<String>) {
    val scan = Scanner(System.`in`)
    val (x, y, z) = scan.nextLine().split(" ").map { it.toInt() }
    var (a, b, c) = scan.nextLine().split(" ").map { it.toInt() }

    if (a < x) {
        println("NO")
        return
    }

    a -= x // 3

    var greenAndPurple = a + b

    if(y < greenAndPurple) {
        println("NO")
        return
    }

    greenAndPurple -= y

    val allGrapes = greenAndPurple + z
    if(allGrapes < z) {
        println("NO")
        return
    }

    println("YES")
}

fun readInt(): Long = readLine()!!.toLong()
fun readInts(): List<Long> = readLine().orEmpty().split(" ").map { it.toLong() }

fun main() {
    val x = readInts().cumsum()
    val y = readInts().cumsum()

    val yes = (x zip y).all { (a, b) -> a >= b }

    println(if (yes) "YES" else "NO")
}

fun <T, R> Iterable<T>.reductions(initial: R, operation: (acc: R, T) -> R): Sequence<R> = sequence {
    var last = initial
    forEach {
        last = operation(last, it)
        yield(last)
    }
}

fun List<Long>.cumsum() = this.reductions(0L) { acc, l -> acc + l }.toList()

fun main() {
    val want = readLine()!!.split(" ").map{it.toInt()}
    val box  = readLine()!!.split(" ").map{it.toInt()}

    when {
        (box[0]+box[1]+box[2]-want[0]-want[1]) < want[2] -> println("NO")
        box[0]<want[0] -> println("NO")
        box[0]-want[0]+box[2]-want[2]+box[1]<want[1] -> println("NO")
        else -> println("YES")
    }

}

import java.util.*

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main(args: Array<String>) {

    var (x, y, z) = readInts()
    var (green, purple, black) = readInts()

    var temp: Int

    temp = green-x
    if (temp < 0) {
        println("NO")
        return
    } else {
        green -= x
    }
    temp = (green + purple)-y
    if (temp < 0) {
        println("NO")
        return
    } else {
        val pur = y - green
        val gre = y - purple
        green -= gre
        purple -= pur
    }

    temp = (green + purple + black)-z

    if (temp < 0) {
        println("NO")
        return
    }
    println("YES")

}

fun main() {
    println(
        if (gotGrapes()) { "YES" } else { "NO" }
    )
}

fun gotGrapes() : Boolean {
    var (andrew, dimitry, michal) = readLine()!!.split(" ").map(String::toInt)
    var (green, purple, black) = readLine()!!.split(" ").map(String::toInt)

    green -= andrew

    if (green < 0) return false

    val i = kotlin.math.min(dimitry, green)
    dimitry -= i
    green -= i
    purple - dimitry

    if (purple < 0) return false

    return (green + purple + black) >= michal
}

fun main(args: Array<String>) {
    solve()
}

private fun read(delimit: Char=' ') = readLine()!!.split(delimit)

private fun solve() {
    var (a, d, m) = read().map(String::toInt)
    var (g, p, b) = read().map(String::toInt)
    var ans = "YES"
    if (g < a) ans = "NO"
    else if ((g + p) < (a + d)) ans = "NO"
    else if ((g + p + b) <= (a + d + m)) ans = "NO"
    println(ans)

}

import java.util.*

fun main(args: Array<String>) = with(Scanner(System.`in`)) {

    val needs = nextLine()!!.split("\\s".toRegex())
    val peopleNeeds = needs.map { it.toInt() }.toMutableList()
    val grapes = nextLine()!!.split("\\s".toRegex()).map { it.toInt() }.toMutableList()

    val peopleGrapes = listOf(intArrayOf(0), intArrayOf(0, 1), intArrayOf(0, 1, 2))

    val enoughGrapes = hasEnoughtGrapes(peopleNeeds, grapes, peopleGrapes)

    if (enoughGrapes) {
        println("YES")
    } else {
        println("NO")
    }

}

fun hasEnoughtGrapes(peopleNeeds: MutableList<Int>, grapes: MutableList<Int>, peopleGrapes: List<IntArray>): Boolean {

    peopleNeeds.forEachIndexed { personIndex, need ->

        peopleGrapes[personIndex].forEachIndexed { index, grapeIndex ->
            val grapeAmount = grapes[grapeIndex]
            if (grapeAmount >= need) {
                grapes[grapeIndex] -= need
                peopleNeeds[personIndex] = 0
            } else {
                grapes[grapeIndex] = 0
                peopleNeeds[personIndex] -= grapeAmount
            }
        }

        if (peopleNeeds[personIndex] > 0 ) {
            return false
        }
    }

    return true

}

fun main() {
    val (andrew, dimitry, michael) = readLine()!!.split(" ").map(Integer::valueOf)
    var (green, purple, black) = readLine()!!.split(" ").map(Integer::valueOf)
    var a = false
    var b = false
    var c = false

    if (green >= andrew) {
        green -= andrew
        a = true
    }

    if (green + purple >= dimitry) {
        var remaining = dimitry
        if (remaining - green >= 0) {
            val removed = green
            remaining -= green
            green -= removed

        }

        if (remaining != 0 && purple >= remaining) {
            val removed = remaining
            purple -= removed
            remaining = 0
        }

        if (remaining == 0) {
            b = true
        }
    }

    if (black + green + purple >= michael) {
        c = true
    }

    if (a && b && c) {
        println("YES")
    } else {
        println("NO")
    }
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map {it.toInt()}
    val (a, b, c) = readLine()!!.split(" ").map {it.toInt()}
    if (x > a) {
        print("NO")
        return
    }
    val r = a - x
    if (y > r + b) {
        print("NO")
        return
    }
    if (z > c) {
        print("NO")
        return
    }
    print("YES")
}

import kotlin.math.min

fun main(){
    var (a, d, m) = readInts()
    var (g, p, b) = readInts()

    if (g < a) {
        println("NO")
        return
    }
    g -= a

    if (g+p < d) {
        println("NO")
        return
    }

    d -= g
    g = min(0, g-p)
    p -= d

    if (g+p+b < m) {
        println("NO")
        return
    }

    println("YES")
}

private fun readLn(): String = readLine()!!
private fun readInt(): Int = readLn().toInt()
private fun readStrings(): List<String> = readLn().split(" ")
private fun readInts(): List<Int> = readStrings().map { it.toInt() }
private fun readLines(n: Int): List<String> = (0 until n).map { readLn() }
private fun readIntLines(n: Int): List<Int> = readLines(n).map { it.toInt() }
private fun String.isPalindrome(): Boolean = this == this.reversed()
private fun String.containsSameChar(): Boolean = this.toCharArray().groupBy { it }.size == 1
private fun String.rotate(n: Int): String = drop(n % length) + take(n % length)

fun  main( args :  Array<String>) {

    val (x,y,z)=readLine()!!.split(" ").map{it.toInt()}
    var (a,b,c)=readLine()!!.split(" ").map{it.toInt()}

    if (x<=a){
        a-=x
        if (y<=a+b){
            c=c+a+b-y
        }else{
            println("NO")
        }
        if (z>c){
            println("NO")
        }
        println("YES")
    }else{
        println("NO")
    }

}

fun main(args : Array<String>) {

    val NT = 1//readLine()?.toInt() ?: 0

    for(test in 1..NT){
        val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
        val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
        val ok = a >= x && a + b >= x + y && a + b + c >= z
        println(if(ok)"YES" else "NO")
    }

}

fun main() {
    val (a, d, m) = readLine()!!.split(' ').map(String::toInt)
    val (g, v, b) = readLine()!!.split(' ').map(String::toInt)

    //a - g
    //d -  g v
    //m - g v b

    var g1 = g
    var v1 = v
    val a1: Int
    val d1: Int

    val m1 = m - b

    //misha check
    if (m1 > 0) {
        v1 = v - m1
        if (v1 < 0) {
            print("NO")
        } else {
            //dima check
            d1 = d - v1
            if (d1 > 0) {
                g1 = g - d1
                if (g1 < 0) {
                    print("NO")
                } else {
                    //g1 - зеленые остались
                    //andrew check
                    a1 = a - g1
                    if (a1 > 0) {
                        print("NO")
                    } else {
                        print("YES")
                    }
                }
            }
        }
    } else {
        //dima check
        d1 = d - v1
        if (d1 > 0) {
            g1 = g - d1
            if (g1 < 0) {
                print("NO")
            } else {
                //g1 - зеленые остались
                //andrew check
                a1 = a - g1
                if (a1 > 0) {
                    print("NO")
                } else {
                    print("YES")
                }
            }
        }else{
            //andrew check
            a1 = a - g1
            if (a1 > 0) {
                print("NO")
            } else {
                print("YES")
            }
        }
    }
}

import java.util.Scanner;

fun main() {
    with(Scanner(System.`in`)) {
        var x = nextInt()
        var y = nextInt()
        var z = nextInt()
        var a = nextInt() // green
        var b = nextInt() // purple
        var c = nextInt() // black
        a = a - x
        if (a < 0) {
            println("NO")!!
            return
        }
        if (b >= y) {
            b = b - y
            y = 0
        } else {
            y = y - b
            b = 0
        }
        if (c >= y) {
            c = c - y
            y = 0
        } else {
            y = y - c
            c = 0
        }
        if (y > 0) {
            println("NO")!!
            return
        }
        if (a + b + c >= z) {
            println("YES")!!
        } else {
            println("NO")!!
        }
    }
}

fun main(args : Array<String>) {

    val NT = 1//readLine()?.toInt() ?: 0

    for(test in 1..NT){
        var (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
        var (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
        var ok = true
        a -= x
        if(a<0)ok = false
        y -= a
        if(y > 0)b-=y
        if(b < 0)ok = false
        z -= a + b
        c -= z
        if( c < 0)ok = false
        println(if(ok)"YES" else "NO")
    }

}

fun main() {
    val require = readLine()!!.split(" ").map { it.toInt() }.toMutableList()
    val exist = readLine()!!.split(" ").map { it.toInt() }.toMutableList()

    if (require[0] > exist[0]) {
        println("NO"); return
    } else exist[1] += exist[0] - require[0]

    if (require[1] > exist[1]) {
        println("NO"); return
    } else exist[2] += exist[1] - require[1]

    if(require[2] <= exist[2]) println("YES")
}

const val GREEN = 0
const val PURPLE = 1
const val BLACK = 2
const val ANDREW = 0
const val DIMITRY = 1
const val MICHAEL = 2
fun main() {
    val request = readLine()!!.split(" ").map { it.toInt() }
    val box = readLine()!!.split(" ").map { it.toInt() }

    var green = box[GREEN]
    green -= request[ANDREW]

    if(green < 0){
        println("NO")
        return
    }

    var greenAndPurple = box[PURPLE] + green
    greenAndPurple -= request[DIMITRY]

    if (greenAndPurple < 0)
        println("NO")
    else if (greenAndPurple + request[BLACK] >= request[MICHAEL])
        println("YES")

}

fun good (a: CharArray) : Int {

    for (i in 0..a.size-1) {
        if (a[i] != a[a.size - i - 1])
            return 1
    }
    return 0
}

fun taskC() {
    var t = readLine()!!.toInt()
    while (t--  > 0) {
        var a = readLine()!!.toString()
        var arr = a.toCharArray()
        arr.sort()
        if (good(arr) == 1)
            println(arr.joinToString(""))
        else
            println(-1)
    }
}
fun taskD() {
    var a = readLine()!!.map {it.toInt()}
    var b = readLine()!!.map {it.toInt()}
    var sum = 0
    for (i in 0..2) {
        sum += b[i]
        if (sum >= a[i]) {
            sum -= a[i]
        }
        else {
            print("NO")
            return
        }
    }
    print("YES")
}

fun main()
{
    taskD()
    return

}
fun taskB() {
    var (a, b, c) = readLine()!!.split(" ").map{it.toInt()}
    var mn = Math.min (a, Math.min (b-1, c-2))
    print(mn + mn + 1 + mn + 2)
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    if (x > a || x + y > a + b || z > c) println("NO") else println("YES")
}

const val GREEN = 0
const val PURPLE = 1
const val BLACK = 2
const val ANDREW = 0
const val DIMITRY = 1
const val MICHAEL = 2
fun main() {
    val request = readLine()!!.split(" ").map { it.toInt() }
    val box = readLine()!!.split(" ").map { it.toInt() }

    var green = box[GREEN]
    green -= request[ANDREW]

    var greenAndPurple = box[PURPLE] + green
    greenAndPurple -= request[DIMITRY]

    if (green < 0 || greenAndPurple < 0)
        println("NO")
    else if (green + greenAndPurple + request[BLACK] >= request[MICHAEL])
        println("YES")

}

fun main(args: Array<String>) {
    val (andrew, dmitry, mischal) = readLine()!!.map { it.toInt() }
    val (green, purple, black) = readLine()!!.map { it.toInt() }

    if (green < andrew) {
        println("NO")
        return
    }
    val remainGreen = green - andrew
    if (remainGreen + purple < dmitry) {
        println("NO")
        return
    }
    if (green + purple + black < andrew + dmitry + mischal) {
        println("NO")
        return
    }
    println("YES")
}

fun main() {
    var (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    var (green, purple, black) = readLine()!!.split(" ").map { it.toInt() }

    var condition = true

    if (green < x) {
        condition = false
    }
    else {
        green -= x
    }

    if (green + purple < y) {
        condition = false
    }
    else {
        if (y >= purple) {
            y -= purple
        }
        else {
            purple -= y
        }

        if (y >= 0) {
            green -= y
        }
    }

    if (purple + green + black < z) {
        condition = false
    }

    println(if (condition) "YES" else "NO")
}

// https://kotlinlang.org/docs/tutorials/competitive-programming.html
// https://stackoverflow.com/questions/41283393/reading-console-input-in-kotlin

private fun readln() = readLine()!!
private fun readlnByte() = readln().toByte()
private fun readlnShort() = readln().toShort()
private fun readlnInt() = readln().toInt()
private fun readlnLong() = readln().toLong()
private fun readlnFloat() = readln().toFloat()
private fun readlnDouble() = readln().toDouble()
private fun readlnBigInt(radix: Int = 10) = readln().toBigInteger(radix)
private fun readlnBigDecimal() = readln().toBigDecimal()

private fun lineSequence(limit: Int = Int.MAX_VALUE) = generateSequence { readLine() }.constrainOnce().take(limit)
private fun readlnStrings() = readln().split(' ')
private fun readlnBytes() = readlnStrings().map { it.toByte() }
private fun readlnShorts() = readlnStrings().map { it.toShort() }
private fun readlnInts() = readlnStrings().map { it.toInt() }
private fun readlnLongs() = readlnStrings().map { it.toLong() }
private fun readlnFloats() = readlnStrings().map { it.toFloat() }
private fun readlnDoubles() = readlnStrings().map { it.toDouble() }

private fun readByteArray() = readlnStrings().run { ByteArray(size) { get(it).toByte() } }
private fun readShortArray() = readlnStrings().run { ShortArray(size) { get(it).toShort() } }
private fun readIntArray() = readlnStrings().run { IntArray(size) { get(it).toInt() } }
private fun readLongArray() = readlnStrings().run { LongArray(size) { get(it).toLong() } }
private fun readFloatArray() = readlnStrings().run { FloatArray(size) { get(it).toFloat() } }
private fun readDoubleArray() = readlnStrings().run { DoubleArray(size) { get(it).toDouble() } }

private fun readlnByteArray(n: Int) = ByteArray(n) { readlnByte() }
private fun readlnShortArray(n: Int) = ShortArray(n) { readlnShort() }
private fun readlnIntArray(n: Int) = IntArray(n) { readlnInt() }
private fun readlnLongArray(n: Int) = LongArray(n) { readlnLong() }
private fun readlnFloatArray(n: Int) = FloatArray(n) { readlnFloat() }
private fun readlnDoubleArray(n: Int) = DoubleArray(n) { readlnDouble() }

private fun readByteArray2d(rows: Int, cols: Int) = Array(rows) { readByteArray().also { require(it.size == cols) } }
private fun readShortArray2d(rows: Int, cols: Int) = Array(rows) { readShortArray().also { require(it.size == cols) } }
private fun readLongArray2d(rows: Int, cols: Int) = Array(rows) { readLongArray().also { require(it.size == cols) } }
private fun readIntArray2d(rows: Int, cols: Int) = Array(rows) { readIntArray().also { require(it.size == cols) } }
private fun readFloatArray2d(rows: Int, cols: Int) = Array(rows) { readFloatArray().also { require(it.size == cols) } }
private fun readDoubleArray2d(rows: Int, cols: Int) =
    Array(rows) { readDoubleArray().also { require(it.size == cols) } }

private fun isWhiteSpace(c: Char) = c in " \r\n\t"

// JVM-only targeting code follows next

// readString() via sequence is still slightly faster than Scanner
private fun readString() = generateSequence { System.`in`.read().toChar() }
    .dropWhile { isWhiteSpace(it) }.takeWhile { !isWhiteSpace(it) }.joinToString("")

private fun readByte() = readString().toByte()
private fun readShort() = readString().toShort()
private fun readInt() = readString().toInt()
private fun readLong() = readString().toLong()
private fun readFloat() = readString().toFloat()
private fun readDouble() = readString().toDouble()
private fun readBigInt(radix: Int = 10) = readString().toBigInteger(radix)
private fun readBigDecimal() = readString().toBigDecimal()

private fun readBytes(n: Int) = generateSequence { readByte() }.take(n)
private fun readShorts(n: Int) = generateSequence { readShort() }.take(n)
private fun readInts(n: Int) = generateSequence { readInt() }.take(n)
private fun readLongs(n: Int) = generateSequence { readLong() }.take(n)
private fun readFloats(n: Int) = generateSequence { readFloat() }.take(n)
private fun readDoubles(n: Int) = generateSequence { readDouble() }.take(n)

private fun printIntArray(a: IntArray) {
    println(a.joinToString(", "))
}

private fun printLongArray(a: LongArray) {
    println(a.joinToString(", "))
}

private fun printDoubleArray(a: DoubleArray) {
    println(a.joinToString(", "))
}

private fun printFloatArray(a: FloatArray) {
    println(a.joinToString(", "))
}

private fun printStringArray(a: Array<String>) {
    println(a.joinToString(", "))
}

fun main() {
    val (x, y, z) = readlnInts()
    val (a, b, c) = readlnInts()

    if (a >= x && a + b >= x + y && a + b + c > x + y + z) {
        println("YES")
    } else {
        println("NO")
    }
}

import java.lang.Integer.min

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    var (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    a -= x
    if (a < 0) {
        println("NO")
        return
    }
    b -= y - a
    if (b < 0) {
        println("NO")
        return
    }
    c -= z - b - a
    if (c < 0) {
        println("NO")
        return
    }
    println("YES")
}

import java.util.Scanner

fun main(args: Array<String>) {
    exercise4()
}

fun exercise4(){
    val reader = Scanner(System.`in`)
    val andrew = reader.nextInt()
    var dimitri = reader.nextInt()
    val michael = reader.nextInt()

    var green = reader.nextInt()
    var purple = reader.nextInt()
    var black = reader.nextInt()

    green -= andrew
    if (green < 0){
        println("NO")
    } else {
        if (green >= dimitri){
            green -= dimitri
        } else {
            dimitri -= green
            purple -= dimitri
            green = 0
            if (purple < 0){
                println("NO")
            } else {
                if (green + purple + black > michael) {
                    println("YES")
                } else {
                    println("NO")
                }
            }
        }
    }

}

//package com.happypeople.codeforces.c1114

import java.io.ByteArrayInputStream
import java.io.InputStream
import java.util.*

fun main(args: Array<String>) {
    try {
        A1114().run()
    } catch (e: Throwable) {
        println("")
        e.printStackTrace()
    }
}

class A1114 {
    fun run() {
        val sc = Scanner(systemIn())
        val hGreen=sc.nextInt()
        val hNotBlack=sc.nextInt()
        val hAny=sc.nextInt()
        var green=sc.nextInt()
        var purple=sc.nextInt()
        var black=sc.nextInt()

        val m1=hGreen<=green
        green+=hGreen
        val m2=hNotBlack<=green+purple
        val m3=hAny<=green+purple+black-hNotBlack
        val ans =m1 and m2 and m3
        if(ans)
            println("YES")
        else
            println("NO")
    }

    companion object {
        var inputStr: String? = null

        fun systemIn(): InputStream {
            if (inputStr != null)
                return ByteArrayInputStream(inputStr!!.toByteArray())
            else
                return System.`in`
        }

        var printLog = false
        fun log(str: String) {
            if (printLog)
                println(str)
        }
    }
}

const val GREEN = 0
const val PURPLE = 1
const val BLACK = 2
const val ANDREW = 0
const val DIMITRY = 1
const val MICHAEL = 2
fun main() {
    val request = readLine()!!.split(" ").map { it.toInt() }
    val box = readLine()!!.split(" ").map { it.toInt() }

    if (request[ANDREW] > box[GREEN])
        print("NO")
    else {
        val leftOfGreen = box[GREEN] - request[ANDREW]

        val leftOfGreenAndPurple = leftOfGreen + box[PURPLE]

        if (leftOfGreenAndPurple < request[DIMITRY]) {
            println("NO")
        } else {

            val sumOfAllLeft = leftOfGreenAndPurple - request[DIMITRY] + box[BLACK]

            if (sumOfAllLeft < request[MICHAEL]) {
                println("YES")
            } else {
                print("NO")
            }

        }

    }

}

import java.util.Scanner
import java.util.Arrays

fun main(args: Array<String>) {
	val reader = Scanner(System.`in`)

	var x:Int = reader.nextInt()
    	var y:Int = reader.nextInt()
    	var z:Int = reader.nextInt()

    	var a:Int = reader.nextInt()
    	var b:Int = reader.nextInt()
    	var c:Int = reader.nextInt()

	var aux:Int

    	if(a>=x){
		a-=x;
		aux=a+c;
		if(aux>=y){
			aux-=y;
			aux+=b;
			if(aux>=z){
				println("YES");
			}
			else{
				println("NO");
			}
		}
		else{
			println("NO");
		}
    	}
	else{
		println("NO");
	}
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    if (x>a) println("NO")
    if (x+y>a+b) println("NO")
    if (x+y+z>a+b+c) println("NO") else println("YES")
}

fun main() {
    var in1 = readLine()!!
    var in2 = readLine()!!
    var x = in1[0].toInt()
    var y = in1[1].toInt()
    var z = in1[2].toInt()
    var a = in2[0].toInt()
    var b = in2[1].toInt()
    var c = in2[2].toInt()
    a -= x
    if (a < 0){
        println("NO")
    }else{
        a += b-y
        if (a < 0){
            println("NO")
        }else{
            a += c-z
            if (a < 0){
                println("NO")
            }else{
                println("YES")
            }
        }
    }
}

import kotlin.math.min

fun readThree() = readLine()!!.split(" ").map { it.toInt() }
fun main() {
    var (andrew, dmitry, michal) = readThree()
    var (green, purple, black) = readThree()

    green -= andrew

    if (green < 0) println("NO")
    else {
        val greenForDmitry = min(green, dmitry)
        green -= greenForDmitry
        dmitry -= greenForDmitry

        purple -= dmitry
        when {
            purple < 0 -> println("NO")
            green + purple + black <= michal -> println("NO")
            else -> println("YES")
        }
    }
}

import java.util.Scanner

val no = "NO"
val yes = "YES"

fun main() {
    val scanner = Scanner(System.`in`)

    val and = scanner.nextInt()
    var dm = scanner.nextInt()
    val mi = scanner.nextInt()

    var green = scanner.nextInt()
    var purple = scanner.nextInt()
    val black = scanner.nextInt()

    if (and > green) {
        println(no)
        return
    }
    green -= and
    if (dm > green + purple) {
        println(no)
        return
    }
    if (dm > green) {
        dm -= green
        green = 0
        purple -= dm
    } else {
        dm -= green
    }

    println(if (green + purple + black > mi) yes else no)
}

import java.util.*
fun main() {
    with(Scanner(System.`in`)) {
        val x = nextInt()
        val y = nextInt()
        val z = nextInt()
        val g = nextInt()
        val p = nextInt()
        val b = nextInt()
        when {
            g < x || x + y < g + p || x + y + z < g + p + b -> println("NO")
            else -> println("YES")
        }
    }
}

import java.util.*

private fun readLn() = readLine()!! // string line
private fun readInt() = readLn().toInt() // single int
private fun readStrings() = readLn().split(" ") // list of strings
private fun readInts() = readStrings().map { it.toInt() } // list of ints

fun main(args: Array<String>) {

    var(x,y,z) =readInts()
    var(green,purple,black) =readInts()

    var temp:Int

    temp=green-x
    if(temp<0){
        println("NO")
        return
    }else{
        green-x
    }
    temp=(green+purple)-y
    if(temp<0){
        println("NO")
        return
    }else{
        (green+purple)-y
    }

    temp=(green+purple+black)-z

    if(temp<0){
        println("NO")
        return
    }
    println("YES")

}

fun main(args: Array<String>) {
        val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
        var (a, b, c) = readLine()!!.split(" ").map { it.toInt() }

        if (x > a) {
            print("NO")
            return
        }
        a -= x
        if (y > b + c) {
            print("NO")
            return
        }
        if (z > a + (b + c - y)) {
            print("NO")
        } else {
            print("YES")
        }
    }

//package org.korifey.kalgo.codeforces.kotlinheroes

import java.util.*
import kotlin.math.min
import kotlin.reflect.KMutableProperty0

fun exit(r: Boolean) {
    println(if (r) "YES" else "NO")
}

fun subtractMin(a: KMutableProperty0<Int>, b: KMutableProperty0<Int>) {
    val m = min(a.get(), b.get())

    a.set(a.get() - m)
    b.set(b.get() - m)
}

var a : Int = 0
var b : Int = 0
var c : Int = 0

var ax : Int = 0
var bx : Int = 0
var cx : Int = 0

fun main() {

    val scanner = Scanner(System.`in`)
    a = scanner.nextInt()
    b = scanner.nextInt()
    c = scanner.nextInt()

    ax = scanner.nextInt()
    bx = scanner.nextInt()
    cx = scanner.nextInt()

    subtractMin(::a, ::ax)

    if (a > 0)
        return exit(false)

    subtractMin(::b, ::ax)
    subtractMin(::b, ::bx)

    if (b > 0)
        return exit(false)

    subtractMin(::c, ::ax)
    subtractMin(::c, ::bx)
    subtractMin(::c, ::cx)

    if (b > 0)
        return exit(false)

    exit(true)
}

import java.util.*

fun main() {
    val scanner = Scanner(System.`in`)
    var x = scanner.nextInt()
    var y = scanner.nextInt()
    var z = scanner.nextInt()

    var a = scanner.nextInt()
    var b = scanner.nextInt()
    var c = scanner.nextInt()

    a -= x
    if (a < 0) {
        println("NO")
        return
    }

    if (a > 0) {
        a -= y
        if (a < 0) {
            y = a * -1
        }
    }

    b -= y
    if (b < 0) {
        println("NO")
        return
    }

    if (b > 0) {
        b -= z
        if (b < 0) {
            z = b * -1
        }
    }

    c -= z
    if (c < 0) {
        println("NO")
        return
    }

    println("YES")
}

import java.util.*

fun main() {
    val scanner = Scanner(System.`in`)
    var x = scanner.nextInt()
    var y = scanner.nextInt()
    var z = scanner.nextInt()

    var a = scanner.nextInt()
    var b = scanner.nextInt()
    var c = scanner.nextInt()

    a -= x
    if (a < 0) {
        println("NO")
        return
    }

    if (a > 0) {
        a -= y
        if (a < 0) {
            y = a * -1
        } else {
            y = 0
        }
    }

    b -= y
    if (b < 0) {
        println("NO")
        return
    }

    if (b > 0) {
        b -= z
        if (b < 0) {
            z = b * -1
        } else {
            z = 0
        }
    }

    c -= z
    if (c < 0) {
        println("NO")
        return
    }

    println("YES")
}

import java.util.*

fun main() = with(Scanner(System.`in`)) {
    val andrew = nextInt()
    val dmitry = nextInt()
    val michel = nextInt()

    var green = nextInt()
    var purple = nextInt()
    var black = nextInt()
    var total = green + purple + black

    if (green < andrew) {
        println("NO")
        return@with
    }
    green -= andrew

    if (green + purple < dmitry) {
        println("NO")
        return@with
    }
    total -= dmitry

    if (total < michel) {
        println("NO")
        return@with
    }

    println("YES")
}

import java.util.Scanner

fun main() {
    val sc = Scanner(System.`in`)

    var x:Int = sc.nextInt()
    var y:Int = sc.nextInt()
    var z:Int = sc.nextInt()
    var a:Int = sc.nextInt()
    var b:Int = sc.nextInt()
    var c:Int = sc.nextInt()

    a -= x
    if (a > 0) {
        if (a + b >= y)
            if (a + b + c >= y + z)
                println("YES")
            else
                println("NO")
        else
            println("NO")
    }
    else
        println("NO")
}

fun main() {
    val (x, y, z) = readLine()!!.split(' ').map { it.toInt() }
    val (a, b, c) = readLine()!!.split(' ').map { it.toInt() }
    if (a >= x && a - x + b >= y && y - (a - x + b) + c >= z) {
        println("YES")
    } else {
        println("NO")
    }
}

import java.util.*

fun main(args: Array<String>) {
    val scan = Scanner(System.`in`)
    val (x, y, z) = scan.nextLine().split(" ").map { it.toInt() }
    var (a, b, c) = scan.nextLine().split(" ").map { it.toInt() }

    if (x > a) {
        println("NO")
        return
    }

    a -= x // 3

    var greenAndPurple = a + b

    if(y > greenAndPurple) {
        println("NO")
        return
    }

    greenAndPurple -= y

    val allGrapes = greenAndPurple + z
    if(z > allGrapes) {
        println("NO")
        return
    }

    println("YES")
}

fun anyGrapes(want:List<String>, grapes:List<String>){
    if(want[0].toInt() > grapes[0].toInt()){
        println("NO")
    }
    else {
        val dymiCurr = want[1].toInt()
        val michCurr = want[2].toInt() - grapes[2].toInt() //Michael gets all black grapes
        val remainGrPu = (grapes[0].toInt() + grapes[1].toInt()) - (want[0].toInt()) //remaining green and purple grapes

        if ( remainGrPu >= 0 &&((dymiCurr+michCurr) - remainGrPu) > 0){
            println("NO")
            return
        }
        println("YES")
    }
}

fun main(args:Array<String>){
    val want = readLine()!!.split(" ")
    val grapes = readLine()!!.split(" ")
    anyGrapes(want, grapes)
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map(String::toInt)
    val (a, b, c) = readLine()!!.split(" ").map(String::toInt)
    if (a >= x && a + b >= x + y && a + c + c >= x + y + z) print("YES") else print("NO")
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    if (x > a || x + y > a + b || z > c) println("NO") else println("YES")
}

fun main() {
    val want = readLine()!!.split(" ").map{it.toInt()}
    val box  = readLine()!!.split(" ").map{it.toInt()}

    when {
        (box[0]+box[1]+box[2]-want[0]-want[1]) < want[2] -> println("NO")
        box[0]<want[0] -> println("NO")
        box[0]-want[0]+box[2]-want[2]+box[1]<want[1] -> println("NO")
        else -> println("YES")
    }

}

  fun main(args:Array<String>){
    val (a, b, c) = readLine()!!.split(' ')
    var x1:Int = a.toInt()
    var y1:Int = b.toInt()
    var z1:Int = c.toInt()
    val (a1, b1, c1) = readLine()!!.split(' ')
    var x:Int = a1.toInt()
    var y:Int = b1.toInt()
    var z:Int = c1.toInt()
    var flag = 0
    if(x1 <= x && flag == 0) {x -= x1}
    else {flag = 1}

    if(y1 <= (y + x) && flag == 0)
        {if(y1 <= y) y -= y1
        else y = 0; x -= (y1 - y)}
    else {flag = 1}

    if(z1 <= (x + y + z) && flag == 0) {flag = 0}
    else {flag = 1}

    if(flag == 0) {println("YES")}
    else {println("NO")}
}

import java.util.Scanner
import java.util.Arrays

fun main(args: Array<String>) {
	val reader = Scanner(System.`in`)

	var x:Int = reader.nextInt()
    	var y:Int = reader.nextInt()
    	var z:Int = reader.nextInt()

    	var a:Int = reader.nextInt()
    	var b:Int = reader.nextInt()
    	var c:Int = reader.nextInt()

	var aux:Int

    	if(a>=x){
		a-=x;
		aux=a+c;
		if(aux>=y){
			aux-=y;
			aux+=b;
			if(aux>=z){
				println("YES");
			}
			else{
				println("NO");
			}
		}
		else{
			println("NO");
		}
    	}
	else{
		println("NO");
	}
}

fun main(args: Array<String>) {
    val (andrew, dmitry, mischal) = readLine()!!.map { it.toInt() }
    val (green, purple, black) = readLine()!!.map { it.toInt() }

    if (green < andrew) {
        println("NO")
        return
    }
    val remainGreen = green - andrew
    if (remainGreen + purple < dmitry) {
        println("NO")
        return
    }
    val remain = remainGreen + purple - andrew
    if (remain + black < mischal) {
        println("NO")
        return
    }
    println("YES")
}

import kotlin.math.max

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }

    if (x > a) {
        println("NO")
        return
    }

    val da1 = a - x
    if (y > da1 + b) {
        println("NO")
        return
    }

    val da2 = max(0, da1 - y)
    val db1 = b + da1 - y
    if (z > da2 + db1 + c) {
        println("NO")
        return
    }

    println("YES")
}

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

fun canEat(): Boolean {
    var x = inp.nextInt()
    var y = inp.nextInt()
    var z = inp.nextInt()

    var a = inp.nextInt()
    var b = inp.nextInt()
    var c = inp.nextInt()

    if (x > a) {
        return false
    }
    a -= x
    x = 0

    val canYEatGreen = minOf(y, a)
    a -= canYEatGreen
    y -= canYEatGreen

    if (y > b) {
        return false
    }
    b -= y
    y = 0

    val canZEatFio = minOf(z, c)
    c -= canZEatFio
    z -= canZEatFio

    return c >= z
}

fun run() {
    val res: String = if (canEat()) "YES" else "NO"
    out.println(res)
}

private val inp = FastInput()
private val out = FastOutput()

fun main() {
    run()
    out.flush()
    out.close()
}

internal class FastInput(private val bufferedReader: BufferedReader) {
    private var tokenizer: StringTokenizer? = null

    constructor() : this(System.`in`)
    constructor(stream: InputStream) : this(BufferedReader(InputStreamReader(stream)))
    constructor(file: File) : this(BufferedReader(FileReader(file)))

    operator fun next(): String {
        while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
            tokenizer = StringTokenizer(bufferedReader.readLine())
        }
        return tokenizer!!.nextToken()
    }

    fun nextInt(): Int = next().toInt()
    fun nextLong(): Long = next().toLong()
}

internal class FastOutput constructor(outputStream: OutputStream = System.out) {
    private val bufferedWriter = BufferedWriter(OutputStreamWriter(outputStream))

    private fun <T> printOne(obj: T) {
        bufferedWriter.write("$obj")
    }

    fun <T> println(obj: T) = bufferedWriter.write("$obj\n")

    fun print(vararg objs: Any) = printd("", *objs)

    fun printd(delimiter: String, vararg objs: Any) {
        for (i in 0 until objs.size) {
            printOne(objs[i])
            printOne(delimiter)
        }
    }

    fun flush() = bufferedWriter.flush()
    fun close() = bufferedWriter.close()
}

fun main(){
    var (x, y, z) = readLine()!!.split(" ").map{ it.toInt() }
    var (a, b, c) = readLine()!!.split(" ").map{ it.toInt() }

    var ok = true
    if(x > a) ok = false
    a -= x
    z -= minOf(z, c)
    if(a + b + c < y + z) ok = false

    println(if (ok) "YES" else "NO")

}

import java.util.*
fun main() {
    with(Scanner(System.`in`)) {
        val x = nextInt()
        val y = nextInt()
        val z = nextInt()
        val g = nextInt()
        val p = nextInt()
        val b = nextInt()
        when {
            g < x || x + y < g + p || x + y + z < g + p + b -> println("NO")
            else -> println("YES")
        }
    }
}

fun main() {
    val (x, y, z) = readLine()!!.split(" ").map { it.toInt() }
    val (a, b, c) = readLine()!!.split(" ").map { it.toInt() }
    if (x>a) println("No")
    if (x+y>a+b) println("No")
    if (x+y+z>a+b+c) println("No") else  println("Yes")
}

import java.util.Scanner

fun main(args: Array<String>) {
    exercise4()
}

fun exercise4(){
    val reader = Scanner(System.`in`)
    val andrew = reader.nextInt()
    var dimitri = reader.nextInt()
    val michael = reader.nextInt()

    var green = reader.nextInt()
    var purple = reader.nextInt()
    var black = reader.nextInt()

    green -= andrew
    if (green < 0){
        println("NO")
    } else {
        if (green >= dimitri){
            green -= dimitri
        } else {
            dimitri -= green
            purple -= dimitri
            green = 0
            if (purple < 0){
                println("NO")
            }
        }
        if (green + purple + black >= michael) {
            println("YES")
        } else {
            println("NO")
        }

    }

}

fun isEnough(wish: List<Int>, grapes: List<Int>) {
    val enough = grapes[0] >= wish[0] &&
        grapes[0] + grapes[1] >= wish[1] &&
        grapes[1] + grapes[1] + grapes[2] >= wish[2]
    println(when(enough) {
        true -> "YES"
        else -> "NO"
    })
}

fun main() {
    val wish = readLine()!!.split(" ").map { it.toInt() }
    val grapes = readLine()!!.split(" ").map { it.toInt() }

    isEnough(wish, grapes)
}