var stdin_input = "";
var stdin_input_itr;
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { stdin_input_itr = stdin_input.split('\n').values(); main(); });

const rl = () => stdin_input_itr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));

var deb; const log = msg => (typeof deb != "undefined") && console.log("DEBUG", msg);

function main () {
	let T = rn();
	while (T--) {
		const n = rn();
		const s = rl();

		let zeroPos;
		let mid = (n >> 1) - 1;
		for (let i = mid + 1; i < n; i++) if (s[i] == '0') zeroPos = i;

		if (zeroPos) {
			++zeroPos;
			console.log(1, zeroPos, 1, zeroPos - 1);
		} else {
			if (s[mid] == '0') {
				++mid;
				console.log(mid, n, mid + 1, n);
			} else {
				++mid;
				console.log(mid, n - 1, mid + 1, n);
			}
		}
	}
}

'use strict'
var os = require('os')
function createInput(n) {
  const t = n.stdin || process.stdin,
    e = /-?\d+/g,
    r = /-?\d+(?:\.\d+)?/g
  let u = [],
    i = 0
  return {
    init: async function () {
      const n = []
      ;(u = await new Promise(e => {
        t.on('data', t => n.push(t)),
          t.on('end', function () {
            const t = n.join('').split(os.EOL)
            e(t)
          })
      })),
        (i = 0)
    },
    dried: function () {
      return i >= u.length
    },
    readLine: o,
    readLineAsNumber: function () {
      return Number(o())
    },
    readIntegersOfLine: function () {
      const n = o().match(e)
      return null == n ? [] : n.map(n => Number(n))
    },
    readNumsOfLine: function () {
      const n = o().match(r)
      return null == n ? [] : n.map(n => Number(n))
    },
  }
  function o() {
    return u[i++]
  }
}
function createOutput(n) {
  const t = n.stdout || process.stdout,
    e = n.encoding || 'ascii',
    r = n.outputBufferThreshold || 1 << 24,
    u = Buffer.alloc(r)
  let i = 0
  return {
    flush: o,
    print: function (n) {
      c('string' == typeof n ? n : n.toString())
    },
    println: function (n) {
      c(('string' == typeof n ? n : n.toString()).concat('\n'))
    },
  }
  function o() {
    t.write(u.toString(e, 0, i)), (i = 0)
  }
  function c(n) {
    const c = Buffer.byteLength(n, e)
    r - i < c && (o(), c >= r) ? t.write(n) : (u.write(n, i, e), (i += c))
  }
}
function createInputAndOutput(n) {
  return {
    ...createInput({ stdin: n.stdin, encoding: n.encoding }),
    ...createOutput({
      stdout: n.stdout,
      encoding: n.encoding,
      outputBufferThreshold: n.outputBufferThreshold,
    }),
  }
}
async function __main__(n, t, e = {}) {
  const r = createInputAndOutput(e)
  await Promise.all([r.init(), Promise.resolve(t && t())]),
    await n(r),
    r.flush()
}
__main__(function (n) {
  const t = n.readLineAsNumber()
  for (let r = 1; r <= t; ++r) {
    const t = e(n.readLineAsNumber(), n.readLine().trim()).map(n => n + 1)
    n.println(t.join(' '))
  }
  function e(n, t) {
    const e = n >> 1
    for (let r = e; r < n; ++r) if ('0' === t[r]) return [0, r, 0, r - 1]
    for (let r = 0, u = n - e; r < u; ++r)
      if ('0' === t[r]) return [r, n - 1, r + 1, n - 1]
    return [1, e, 0, e - 1]
  }
})

var stdin_input = "";
var stdin_input_itr;
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { stdin_input_itr = stdin_input.split('\n').values(); main(); });

const rl = () => stdin_input_itr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));

var deb; const log = msg => (typeof deb != "undefined") && console.log("DEBUG", msg);

function main () {
	let T = rn();
	while (T--) {
		const n = rn();
		const s = rl();

		let zeroPos;
		for (let i = 0; i < n; i++) if (s[i] == '0') zeroPos = i + 1;

		if (zeroPos) {
			if (zeroPos <= n >> 1 ) {
				console.log(zeroPos, n, zeroPos + 1, n);
			} else {
				console.log(1, zeroPos, 1, zeroPos - 1);
			}
		} else {
			console.log(1, n - 1, 2, n);
		}
	}
}

'use strict'
var os = require('os')
function createInput(n) {
  const t = n.stdin || process.stdin,
    e = /-?\d+/g,
    r = /-?\d+(?:\.\d+)?/g
  let u = [],
    i = 0
  return {
    init: async function () {
      const n = []
      ;(u = await new Promise(e => {
        t.on('data', t => n.push(t)),
          t.on('end', function () {
            const t = n.join('').split(os.EOL)
            e(t)
          })
      })),
        (i = 0)
    },
    dried: function () {
      return i >= u.length
    },
    readLine: o,
    readLineAsNumber: function () {
      return Number(o())
    },
    readIntegersOfLine: function () {
      const n = o().match(e)
      return null == n ? [] : n.map(n => Number(n))
    },
    readNumsOfLine: function () {
      const n = o().match(r)
      return null == n ? [] : n.map(n => Number(n))
    },
  }
  function o() {
    return u[i++]
  }
}
function createOutput(n) {
  const t = n.stdout || process.stdout,
    e = n.encoding || 'ascii',
    r = n.outputBufferThreshold || 1 << 24,
    u = Buffer.alloc(r)
  let i = 0
  return {
    flush: o,
    print: function (n) {
      c('string' == typeof n ? n : n.toString())
    },
    println: function (n) {
      c(('string' == typeof n ? n : n.toString()).concat('\n'))
    },
  }
  function o() {
    t.write(u.toString(e, 0, i)), (i = 0)
  }
  function c(n) {
    const c = Buffer.byteLength(n, e)
    r - i < c && (o(), c >= r) ? t.write(n) : (u.write(n, i, e), (i += c))
  }
}
function createInputAndOutput(n) {
  return {
    ...createInput({ stdin: n.stdin, encoding: n.encoding }),
    ...createOutput({
      stdout: n.stdout,
      encoding: n.encoding,
      outputBufferThreshold: n.outputBufferThreshold,
    }),
  }
}
async function __main__(n, t, e = {}) {
  const r = createInputAndOutput(e)
  await Promise.all([r.init(), Promise.resolve(t && t())]),
    await n(r),
    r.flush()
}
__main__(function (n) {
  const t = n.readLineAsNumber()
  for (let r = 1; r <= t; ++r) {
    const t = e(n.readLineAsNumber(), n.readLine().trim()).map(n => n + 1)
    n.println(t.join(' '))
  }
  function e(n, t) {
    const e = n >> 1
    for (let r = e; r < n; ++r) if ('0' === t[r]) return [0, r, 0, r - 1]
    for (let r = 0, u = n - e; r < u; ++r)
      if ('0' === t[r]) return [r, n - 1, r + 1, n - 1]
    return 1 & e ? [0, e + 2, 0, e] : [0, e + 1, 0, e - 1]
  }
})

'use strict'
var os = require('os')
function createInput(n) {
  const t = n.stdin || process.stdin,
    e = /-?\d+/g,
    r = /-?\d+(?:\.\d+)?/g
  let u = [],
    i = 0
  return {
    init: async function () {
      const n = []
      ;(u = await new Promise(e => {
        t.on('data', t => n.push(t)),
          t.on('end', function () {
            const t = n.join('').split(os.EOL)
            e(t)
          })
      })),
        (i = 0)
    },
    dried: function () {
      return i >= u.length
    },
    readLine: o,
    readLineAsNumber: function () {
      return Number(o())
    },
    readIntegersOfLine: function () {
      const n = o().match(e)
      return null == n ? [] : n.map(n => Number(n))
    },
    readNumsOfLine: function () {
      const n = o().match(r)
      return null == n ? [] : n.map(n => Number(n))
    },
  }
  function o() {
    return u[i++]
  }
}
function createOutput(n) {
  const t = n.stdout || process.stdout,
    e = n.encoding || 'ascii',
    r = n.outputBufferThreshold || 1 << 24,
    u = Buffer.alloc(r)
  let i = 0
  return {
    flush: o,
    print: function (n) {
      c('string' == typeof n ? n : n.toString())
    },
    println: function (n) {
      c(('string' == typeof n ? n : n.toString()).concat('\n'))
    },
  }
  function o() {
    t.write(u.toString(e, 0, i)), (i = 0)
  }
  function c(n) {
    const c = Buffer.byteLength(n, e)
    r - i < c && (o(), c >= r) ? t.write(n) : (u.write(n, i, e), (i += c))
  }
}
function createInputAndOutput(n) {
  return {
    ...createInput({ stdin: n.stdin, encoding: n.encoding }),
    ...createOutput({
      stdout: n.stdout,
      encoding: n.encoding,
      outputBufferThreshold: n.outputBufferThreshold,
    }),
  }
}
async function __main__(n, t, e = {}) {
  const r = createInputAndOutput(e)
  await Promise.all([r.init(), Promise.resolve(t && t())]),
    await n(r),
    r.flush()
}
__main__(function (n) {
  const t = n.readLineAsNumber()
  for (let r = 1; r <= t; ++r) {
    const t = e(n.readLineAsNumber(), n.readLine().trim()).map(n => n + 1)
    n.println(t.join(' '))
  }
  function e(n, t) {
    const e = n >> 1
    for (let r = e; r < n; ++r) if ('0' === t[r]) return [0, r, 0, r - 1]
    for (let r = 0, u = n - e; r < u; ++r)
      if ('0' === t[r]) return [r, n - 1, r + 1, n - 1]
    return 1 & e ? [0, e + 1, 0, e - 1] : [0, e + 2, 0, e]
  }
})

'use strict'
var os = require('os')
function createInput(n) {
  const t = n.stdin || process.stdin,
    e = /-?\d+/g,
    r = /-?\d+(?:\.\d+)?/g
  let u = [],
    i = 0
  return {
    init: async function () {
      const n = []
      ;(u = await new Promise(e => {
        t.on('data', t => n.push(t)),
          t.on('end', function () {
            const t = n.join('').split(os.EOL)
            e(t)
          })
      })),
        (i = 0)
    },
    dried: function () {
      return i >= u.length
    },
    readLine: o,
    readLineAsNumber: function () {
      return Number(o())
    },
    readIntegersOfLine: function () {
      const n = o().match(e)
      return null == n ? [] : n.map(n => Number(n))
    },
    readNumsOfLine: function () {
      const n = o().match(r)
      return null == n ? [] : n.map(n => Number(n))
    },
  }
  function o() {
    return u[i++]
  }
}
function createOutput(n) {
  const t = n.stdout || process.stdout,
    e = n.encoding || 'ascii',
    r = n.outputBufferThreshold || 1 << 24,
    u = Buffer.alloc(r)
  let i = 0
  return {
    flush: o,
    print: function (n) {
      c('string' == typeof n ? n : n.toString())
    },
    println: function (n) {
      c(('string' == typeof n ? n : n.toString()).concat('\n'))
    },
  }
  function o() {
    t.write(u.toString(e, 0, i)), (i = 0)
  }
  function c(n) {
    const c = Buffer.byteLength(n, e)
    r - i < c && (o(), c >= r) ? t.write(n) : (u.write(n, i, e), (i += c))
  }
}
function createInputAndOutput(n) {
  return {
    ...createInput({ stdin: n.stdin, encoding: n.encoding }),
    ...createOutput({
      stdout: n.stdout,
      encoding: n.encoding,
      outputBufferThreshold: n.outputBufferThreshold,
    }),
  }
}
async function __main__(n, t, e = {}) {
  const r = createInputAndOutput(e)
  await Promise.all([r.init(), Promise.resolve(t && t())]),
    await n(r),
    r.flush()
}
__main__(function (n) {
  const t = n.readLineAsNumber()
  for (let r = 1; r <= t; ++r) {
    const t = e(n.readLineAsNumber(), n.readLine().trim()).map(n => n + 1)
    n.println(t.join(' '))
  }
  function e(n, t) {
    const e = n >> 1
    for (let r = e; r < n; ++r) if ('0' === t[r]) return [0, r, 0, r - 1]
    for (let r = 0, u = n - e; r < u; ++r)
      if ('0' === t[r]) return [r, n - 1, r + 1, n - 1]
    return [-1, -1, -1, -1]
  }
})

'use strict'
var os = require('os')
function createInput(n) {
  const t = n.stdin || process.stdin,
    e = /-?\d+/g,
    r = /-?\d+(?:\.\d+)?/g
  let u = [],
    i = 0
  return {
    init: async function () {
      const n = []
      ;(u = await new Promise(e => {
        t.on('data', t => n.push(t)),
          t.on('end', function () {
            const t = n.join('').split(os.EOL)
            e(t)
          })
      })),
        (i = 0)
    },
    dried: function () {
      return i >= u.length
    },
    readLine: o,
    readLineAsNumber: function () {
      return Number(o())
    },
    readIntegersOfLine: function () {
      const n = o().match(e)
      return null == n ? [] : n.map(n => Number(n))
    },
    readNumsOfLine: function () {
      const n = o().match(r)
      return null == n ? [] : n.map(n => Number(n))
    },
  }
  function o() {
    return u[i++]
  }
}
function createOutput(n) {
  const t = n.stdout || process.stdout,
    e = n.encoding || 'ascii',
    r = n.outputBufferThreshold || 1 << 24,
    u = Buffer.alloc(r)
  let i = 0
  return {
    flush: o,
    print: function (n) {
      c('string' == typeof n ? n : n.toString())
    },
    println: function (n) {
      c(('string' == typeof n ? n : n.toString()).concat('\n'))
    },
  }
  function o() {
    t.write(u.toString(e, 0, i)), (i = 0)
  }
  function c(n) {
    const c = Buffer.byteLength(n, e)
    r - i < c && (o(), c >= r) ? t.write(n) : (u.write(n, i, e), (i += c))
  }
}
function createInputAndOutput(n) {
  return {
    ...createInput({ stdin: n.stdin, encoding: n.encoding }),
    ...createOutput({
      stdout: n.stdout,
      encoding: n.encoding,
      outputBufferThreshold: n.outputBufferThreshold,
    }),
  }
}
async function __main__(n, t, e = {}) {
  const r = createInputAndOutput(e)
  await Promise.all([r.init(), Promise.resolve(t && t())]),
    await n(r),
    r.flush()
}
__main__(function (n) {
  const t = n.readLineAsNumber()
  for (let r = 1; r <= t; ++r) {
    const t = e(n.readLineAsNumber(), n.readLine().trim()).map(n => n + 1)
    n.println(t.join(' '))
  }
  function e(n, t) {
    const e = n >> 1
    for (let r = e; r < n; ++r) if ('0' === t[r]) return [0, r - 1, 0, r]
    for (let r = 0, u = n - e; r < u; ++r)
      if ('0' === t[r]) return [r, n - 1, r + 1, n - 1]
    return [-1, -1, -1, -1]
  }
})

var stdin_input = "";
var stdin_input_itr;
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { stdin_input_itr = stdin_input.split('\n').values(); main(); });

const rl = () => stdin_input_itr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));

var deb; const log = msg => (typeof deb != "undefined") && console.log("DEBUG", msg);

function main () {
	let T = rn();
	while (T--) {
		const n = rn();
		const s = rl();

		let zeroPos;
		let mid = (n >> 1) - 1;
		for (let i = mid + 1; i < n; i++) if (s[i] == '0') zeroPos = i;
		console.log(zeroPos);

		if (zeroPos) {
			++zeroPos;
			console.log(1, zeroPos, 1, zeroPos - 1);
		} else {
			if (s[mid] == '0') {
				++mid;
				console.log(mid, n, mid + 1, n);
			} else {
				++mid;
				console.log(mid, n - 1, mid + 1, n);
			}
		}
	}
}

var stdin_input = "";
var stdin_input_itr;
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { stdin_input_itr = stdin_input.split('\n').values(); main(); });

const rl = () => stdin_input_itr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));

var deb; const log = msg => (typeof deb != "undefined") && console.log("DEBUG", msg);

function main () {
	let T = rn();
	while (T--) {
		const n = rn();
		const s = rl();

		let zeroPos;
		let mid = (n >> 1) - 1;
		for (let i = mid + 1; i < n; i++) if (s[i] == '0') zeroPos = i;

		if (zeroPos) {
			++zeroPos;
			console.log(1, zeroPos - 1, 1, zeroPos);
		} else {
			if (s[mid] == '0') {
				++mid;
				console.log(mid, n, mid + 1, n);
			} else {
				++mid;
				console.log(mid, n - 1, mid + 1, n);
			}
		}
	}
}


'use strict';
var n = parseInt(readline());
var max = -1;
for (var i = 0; i < n; i++) {
    var input = readline().split(' ').map(n => parseInt(n));
    max = Math.max(max, input[0] + input[1])
}
print(max);

function main() {
  const cin = new Scanner();
  let a, b;
  let answer = 0;
  for (let t = cin.nextInt(); t !== 0; t -= 1) {
    [a, b] = cin.nextArray();
    answer = Math.max(answer, a + b);
  }
  console.log(answer);
}

/*
 *  Api Scanner
 */
class Scanner {
  constructor() {
    this.index = -1;
    this.lines = stdinInput.trim().split('\n'); // eslint-disable-line
  }

  nextLine() {
    this.index += 1;
    return this.lines[this.index].trim();
  }

  nextInt() {
    return parseInt(this.nextLine(), 10);
  }

  nextDouble() {
    return parseFloat(this.nextLine());
  }

  nextArray(fn = Number) {
    const array = this.nextLine().split(' ');
    if (fn !== String)
      array.forEach((item, index, arr) => { arr[index] = fn(item); });
    return array;
  }

  hasNext() {
    return this.index < this.lines.length;
  }
}

let stdinInput = '';
process.stdin.resume();
process.stdin.setEncoding('utf-8');
process.stdin.on('data', (input) => { stdinInput += input; });
process.stdin.on('end', () => { main(); });

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});
let c = 0;
let ans = 0;

rl.on('line', (d) => {
  if (c === 0) {
    c++;
    return;
  }

  const [a, b] = d.split(' ').map(Number);
  ans = Math.max(ans, a + b);

  c++;
});

rl.on('close', () => {
  console.log(ans);
});

var n = +readline(), max = -1;
while (n-->0){
    var ip = readline().split(' ').map(Number);
    max = Math.max(max,ip[0]+ip[1]);
}
print(max);

function main(){
    var n = parseInt(readline());
    var maxX = -1;
    var maxY = -1;
    var maxLength = 0;
    for(var i =  0; i < n; ++i){
        var point = readline().split(" ").map(function(x) { return parseInt(x); });
        var x = point[0];
        var y = point[1];
        if(x + y> maxLength){
            maxLength = x + y;
        }
    }
    print(maxLength)
}

main()

var n = parseInt(readline());
var xYSum = 0;

for(var i = 0; i < n; i++)
{
    var a = readline().split(" ");
    var newXYSum = parseInt(a[0]) + parseInt(a[1]);

    if(newXYSum > xYSum)
        xYSum = newXYSum;
}

print(xYSum);

function Nur_Alam(){

    var n = readline();
    var c = -1;

    while(n--){
        var a= readline().split(' ').map(Number);
        c = Math.max(c, a[0]+a[1]);
     }
     print(c);
}

Nur_Alam()

function hlw_callme(){

    var n = readline();
    var c = -1;

    while(n--){
        var a= readline().split(' ').map(Number);
        c = Math.max(c, a[0]+a[1]);
     }
     print(c);
}

hlw_callme();

function main(){
    var n = parseInt(readline());
    var maxX = -1;
    var maxY = -1;
    var maxLength = 0;
    for(var i =  0; i < n; ++i){
        var point = readline().split(" ").map(function(x) { return parseInt(x); });
        var x = point[0];
        var y = point[1];
        if(x * x + y * y > maxLength){
            maxLength = x * x  + y * y;
            maxX = x;
            maxY = y;
        }
    }
    print(x + y)
}

main()

var ans = -1
var n = readline()

for(var i= 0; i < n; i++){
    var a = readline()
    var b = readline()

    var c = Math.max(c, a+b)
}
print(c)

var n = readline()
var c = -1

for(var i= 0; i < n; i++){
    var a = readline()
    var b = readline()

    c = Math.max(c, a+b)
}
print(c)

function main() {
  const cin = new Scanner();
  let a, b;
  let answer = 0;
  for (let t = cin.nextInt(); t !== 0; t -= 1) {
    [a, b] = cin.nextArray(Number);
    answer = Math.max(answer, a + b);
  }

}

/*
 *  Api Scanner
 */
class Scanner {
  constructor() {
    this.index = -1;
    this.lines = stdinInput.trim().split('\n'); // eslint-disable-line
  }

  nextLine() {
    this.index += 1;
    return this.lines[this.index].trim();
  }

  nextInt() {
    return parseInt(this.nextLine(), 10);
  }

  nextDouble() {
    return parseFloat(this.nextLine());
  }

  nextArray(fn = String) {
    const array = this.nextLine().split(' ');
    if (fn !== String)
      array.forEach((item, index, arr) => { arr[index] = fn(item); });
    return array;
  }

  hasNext() {
    return this.index < this.lines.length;
  }
}

let stdinInput = '';
process.stdin.resume();
process.stdin.setEncoding('utf-8');
process.stdin.on('data', (input) => { stdinInput += input; });
process.stdin.on('end', () => { main(); });


process.stdin.setEncoding("ascii");

let input = "";

process.stdin.on("data", data => {
    input += data;
});

process.stdin.on("end", () => {
    const numbers = input.split("\n")[1].split(" ").map(Number);
    numbers.sort((a, b) => a - b);
    const n = numbers.length;
    const [third, second, first, ...theRest] = numbers.reverse();
    if (third >= first + second) {
        console.log("NO");
        return;
    }
    console.log("YES");
    console.log([first, third, second, ...theRest].join(" "));
});

"use strict";

// readline().split(' ').map(value => +value);
var n = +readline();
var A = readline().split(' ').map(value => +value);
A.sort((a, b) => b - a);

if (A[0] >= A[1] + A[2]) {
    write('NO');
} else {
    var result = A.filter((v, i) => !(i%2)).concat(A.filter((v, i) => !!(i%2)).reverse());
    write('YES\n');
    write(result.join(' '));
}

var n = parseInt(readline());
var arr = readline().split(" ").map((i) =>parseInt(i) );

arr.sort((a, b) => a - b);

if (arr[n - 1] >= arr[n - 2] + arr[n - 3]) {
    print("NO");
} else {
    print("YES");

    var output = `${arr[n-2]} ${arr[n-1]} ${arr[n-3]} `;

    arr = arr.splice(0, n-3);

    output += arr.join(" ");

    print(output);
}

readline();
var arr = readline().split(' ').map(item => +item).sort((var1, var2) => var2 - var1);
if (arr[0] < arr[1] + arr[2]) {
  print('YES');
  print([arr[2], arr[0], arr[1]].concat(arr.slice(3)).join(' '))
} else {
  print('NO');
}

var n = parseInt(readline());
var arr = readline().split(" ").map(function(i) { return parseInt(i); });

arr.sort();

if (arr[n - 1] >= arr[n - 2] + arr[n - 3]) {
    print("NO");
} else {
    print("YES");
    print(arr.join(" "))
}

var n = parseInt(readline());
var arr = readline().split(" ").map((i) =>parseInt(i) );

arr.sort((a, b) => a - b);

if (arr[n - 1] >= arr[n - 2] + arr[n - 3]) {
    print("NO");
} else {
    print("YES");
    print(arr.join(" "))
}

process.stdin.setEncoding("ascii");

let input = "";

process.stdin.on("data", data => {
    input += data;
});

process.stdin.on("end", () => {
    console.log("YES");
    console.log("4 2 3");
});


const readline = require('readline');

const rl = readline.createInterface({
    // input: require('fs').createReadStream('input.txt'),
    input: process.stdin,
    output: process.stdout
    // removeHistoryDuplicates: true
});

const it = rl[Symbol.asyncIterator]();

const main = async () => {
    // let use_case;
    // while(true){use_case = await it.next();if(use_case.value !== '')break;}
    let t = (await it.next()).value;
    // let test_case = Number(t);
    let r_t= 1;
    while(t--)
    {
        let n;
        while(true){n = await it.next();if(n.value !== '')break;}
        // n = Number(n.value);
        let arr;
        while(true){arr = await it.next();if(arr.value !== '')break;}
        arr = arr.value.split(' ').map(x => Number(x))
        let el = 0;
        let count = 0;
        let rem = 0;
        arr.forEach(element => {

            if(element > el)
            {
                rem = rem + (element - el - 1);

                el = element;
            }else{
                rem--;
            }

            if(rem === 0)
            {
                count++;
            }

        })
        console.log(count);
        // r_t++;
    }

}
main();

"use strict";

//let startTime = Date.now();

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
    inputString += inputStdin;
});

process.stdin.on("end", (_) => {
    inputString = inputString
        .trim()
        .split("\n")
        .map((string) => {
            return string.trim();
        });

    main();
});

function readline() {
    return inputString[currentLine++];
}

function main() {
    const numOfTests = +(readline());
    let resultString = "";

    for (let i=0; i<numOfTests; i++){
        const lengthOfArr = +(readline());
        const arr = readline().split(" ").map((string) => {
            return +(string);
        });

        let result = [];

        let h = arr[0];
        let l = arr[0];
        let index = 0;

        result.push({
            h: h,
            l:l
        });

        for (let i = 1; i < lengthOfArr; i++) {
            let num = arr[i];

            if (num < h) {
                if (num < l) {
                    l = num;
                    result[index].l = l;
                }

                let prevWasHigher = true;

                do {
                    if (index > 0 && result[index-1].h > l) {
                        index--;
                        result[index].h = h;
                        result[index].l = l;

                        result.pop();
                    } else {
                        prevWasHigher = false;
                    }
                } while (prevWasHigher);
            }
            else {
                result[index] = {
                    h:h,
                    l:l
                };

                h = num;
                l = num;

                result.push({
                    h: h,
                    l:l
                });

                index++;
            }
        }

        resultString += result.length + "\n";
    }

    console.log(resultString);
    //console.log(Date.now() - startTime + " ms");
}

"use strict";

//let startTime = Date.now();

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
    inputString += inputStdin;
});

process.stdin.on("end", (_) => {
    inputString = inputString
        .trim()
        .split("\n")
        .map((string) => {
            return string.trim();
        });

    main();
});

function readline() {
    return inputString[currentLine++];
}

function main() {
    const numOfTests = +(readline());

    for (let i=0; i<numOfTests; i++){
        const lengthOfArr = +(readline());
        const arr = readline().split(" ").map((string) => {
            return +(string);
        });

        let result = [];

        let h = arr[0];
        let l = arr[0];
        let index = 0;

        result.push({
            h: h,
            l:l
        });

        for (let i = 1; i < lengthOfArr; i++) {
            let num = arr[i];

            if (num < h) {
                if (num < l) {
                    l = num;
                    result[index].l = l;
                }

                let prevWasHigher = true;

                do {
                    if (index > 0 && result[index-1].h > l) {
                        index--;
                        result[index].h = h;
                        result[index].l = l;

                        result.pop();
                    } else {
                        prevWasHigher = false;
                    }
                } while (prevWasHigher);
            }
            else {
                result[index] = {
                    h:h,
                    l:l
                };

                h = num;
                l = num;

                result.push({
                    h: h,
                    l:l
                });

                index++;
            }
        }

        console.log(result.length);
    }

    //console.log(Date.now() - startTime + " ms");
}

const readline = require('readline');

const rl = readline.createInterface({
    // input: require('fs').createReadStream('input.txt'),
    input: process.stdin,
    output: process.stdout,
    crlfDelay: Infinity,
});

const it = rl[Symbol.asyncIterator]();

const main = async () => {
    let t = (await it.next()).value;
    while(t--)
    {
        let n = Number((await it.next()).value);
        let arr = (await it.next()).value.split(' ').map(x => Number(x))
        let el = 0;
        let count = 0;
        let rem = 0;
        arr.forEach(element => {

            if(element > el)
            {
                rem = rem + (element - el - 1);

                el = element;
            }else{
                rem--;
            }

            if(rem === 0)
            {
                count++;
            }

        })
        console.log(count);
    }

}
main();

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let stdinInput = '';

process.stdin.on('data', input => {
  stdinInput += input;
})

process.stdin.on('end', () => {
  main(stdinInput);
})

const main = (data) => {
    data = data.split('\n');
    let t = Number(data[0])
    // let test_case = Number(t);
    let line=1;
    let r_t= 1;
    while(t--)
    {
        const n = Number(data[line]);
        line++;
        let i_arr = (data[line]);
        line++;
        let arr = i_arr.split(' ').map( x => Number(x));
        let el = 0;
        let count = 0;
        let rem = 0;

        arr.forEach(element => {

            if(element > el)
            {
                // count++;
                rem = rem + (element - el - 1);

                el = element;
            }else{
                rem--;
            }

            if(rem === 0)
            {
                count++;
            }

        })
        console.log(count);
        // }
        r_t++;
    }

}

'use strict';
 /*jslint node:true, browser:true, es6:true*/
const print = console.log
const E = {};
const lines = []
if (!process.env.JEST_WORKER_ID){
  const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout })
  rl.on('line', line => {
      lines.push(line);
  });
  rl.on('close', main)
}
let rli = 0;
function readline() {
    return lines[rli++];
}
const L = process.env.DEBUG ? console.log : ()=>{};

module.exports = E;
const ra = ()=>readline().split(' ').map(a=>+a)

class DSU {
  constructor(n){
    this.parents = new Array(n).fill(0);
    this.rank = new Array(n).fill(0);
    for (let i=0; i<n; i++)
      this.parents[i] = i;
  }
  get(x){
    if (this.parents[x]==x)
      return x;
    return this.parents[x] = this.get(this.parents[x]);
  }
  unite(x, y){
    x = this.get(x);
    y = this.get(y);
    if (x != y) {
      if (this.rank[x] < this.rank[y]){
        let tmp = x;
        x = y;
        y = tmp;
      }
      this.parents[y] = x;
      if (this.rank[x] == this.rank[y])
        this.rank[x]++;
    }
  }
}

class Heap {
  constructor(){
    this.root = null;
    this.count = 0;
  }
  size(){
    return this.count;
  }
  top(){
    return this.root.value;
  }
  push(value){
    this.root = HeapNode.merge(this.root, new HeapNode(value));
    this.count++;
  }
  pop(){
    if (!this.count)
      return null;
    this.count--;
    let val = this.root.value;
    this.root = HeapNode.merge(this.root.l, this.root.r);
    return val;
  }
}
// max heap
class HeapNode {
  constructor(value, l, r){
    this.value = value;
    this.l = l;
    this.r = r;
  }
  static merge(node1, node2){
    if (!node1)
      return node2;
    if (!node2)
      return node1;
    if (node1.value<node2.value)
      return HeapNode.merge(node2, node1);
    return Math.random()>0.5 ?
     new HeapNode(node1.value, node1.l, HeapNode.merge(node1.r, node2)) :
     new HeapNode(node1.value, HeapNode.merge(node1.l, node2), node1.r);
  }
}

const calc = (n, P)=>{
  let dsu = new DSU(n);
  let heap = new Heap();
  for (let i=0; i<n; i++){
    P[i]--;
    let el = P[i];
    let max = el;
    while (heap.size() && heap.top()>el){
      max = Math.max(max, heap.top());
      dsu.unite(heap.pop(), el);
    }
    heap.push(max);
  }
  let set = new Set();
  for (let i=0; i<n; i++)
    set.add(dsu.get(i))
  return set.size;
};

function main() {
    let T = +readline()
    while (T--){
      let [n] = ra();
      let A = ra();
      L('Ans:')
      print(calc(n, A));
    }
}

E.calc = calc;

"use strict";

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
	inputString += inputStdin;
});

process.stdin.on("end", () => {
	inputString = inputString
		.trim()
		.split("\n")
		.map((string) => {
			return string.trim();
		});

	main();
});

function readline() {
	return inputString[currentLine++];
}

function main() {
	const testCount = +readline();
	let resultString = "";

	for (let i = 0; i < testCount; i++) {
		let arrayLength = +readline();
		let perm = readline()
			.split(" ")
			.map((e) => +e);

		let result = 0;
		let biggest = perm.length;

		const indexLookup = {};
		perm.forEach((e, i) => {
			indexLookup[e] = i;
		});

		while (perm.length > 0) {
			let index = indexLookup[biggest];

			while (index >= perm.length) {
				biggest--;
				index = indexLookup[biggest];
			}

			let end = perm.splice(index);

			if (end.length === 1) {
				result++;
			} else {
				const smallest = end.reduce((small, element) => {
					return Math.min(small, element);
				}, Infinity);
				perm.push(smallest);
				indexLookup[smallest] = perm.length - 1;
			}
			biggest--;
		}

		resultString += result + "\n";
	}

	console.log(resultString);
}

"use strict";

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
	inputString += inputStdin;
});

process.stdin.on("end", () => {
	inputString = inputString
		.trim()
		.split("\n")
		.map((string) => {
			return string.trim();
		});

	main();
});

function readline() {
	return inputString[currentLine++];
}

function main() {
	const testCount = +readline();

	for (let i = 0; i < testCount; i++) {
		let arrayLength = +readline();
		let perm = readline()
			.split(" ")
			.map((e) => +e);

		let result = 0;
		let biggest = perm.length;

		const indexLookup = {};
		perm.forEach((e, i) => {
			indexLookup[e] = i;
		});

		while (perm.length > 0) {
			let index = indexLookup[biggest];

			while (index >= perm.length) {
				biggest--;
				index = indexLookup[biggest];
			}

			let end = perm.splice(index);

			if (end.length === 1) {
				result++;
			} else {
				const smallest = end.reduce((small, element) => {
					return Math.min(small, element);
				}, Infinity);
				perm.push(smallest);
				indexLookup[smallest] = perm.length - 1;
			}
			biggest--;
		}

		console.log(result);
	}
}

'use strict';

function solve(n, a) {
  const st = [n - 1];
  const uf = new UnionFind(n);
  for (let i = n - 2; i >= 0; i--) {
    if (a[i] > a[st[st.length - 1]]) {
      let t = st[st.length - 1];
      while (st.length && a[i] > a[st[st.length - 1]]) {
        const j = st.pop();
        uf.union(i, j);
      }
      st.push(t);
    }
    if (a[i] < a[st[st.length - 1]]) st.push(i);
  }
  const roots = new Set();
  for (let i = 0; i < n; i++) {
    roots.add(uf.find(i));
  }
  return roots.size;
}
class UnionFind {
  constructor(n) {
    this.p = [...new Array(n).keys()];
    this.find = this.find.bind(this);
    this.union = this.union.bind(this);
    this.isConnect = this.isConnect.bind(this);
  }
  find(i) {
    const {
      p
    } = this;
    while (p[i] !== i) {
      p[i] = p[p[i]];
      i = p[i];
    }
    return p[i];
  }
  union(i, j) {
    const {
      p,
      find
    } = this;
    const ri = find(i),
          rj = find(j);
    if (ri !== rj) p[rj] = ri;
  }
  isConnect(i, j) {
    const {
      find
    } = this;
    const ri = find(i),
          rj = find(j);
    return ri === rj;
  }
}

async function main(read) {
  try {
    let t = Number(await read());
    let res = new Array(t);
    for (let i = 0; i < t; i++) {
      const n = Number(await read());
      const a = (await read()).split(' ').map(Number);
      res[i] = solve(n, a);
    }
    return res.join('\n');
  } catch (error) {
    console.log(error);
  }
}

let inputs,
    str = '';
function read() {
  return inputs.next().value.trim();
}
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', input => str += input);
process.stdin.on('end', async () => {
  inputs = str.split('\n').values();
  const output = await main(read);
  process.stdout.write(output);
});

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}
function iInpArr() {
  return readline()
    .trim()
    .split(" ")
    .map((cur) => parseInt(cur));
}
function BInpArr() {
  return readline()
    .trim()
    .split(" ")
    .map((cur) => BigInt(cur));
}
function string() {
  return readline().trim();
}
function stringArr() {
  return readline().trim().split("");
}

function stringArr1() {
  return readline().trim().split(" ");
}
function getValue() {
  return parseInt(readline());
}
function iInpArr1() {
  return readline()
    .trim()
    .split("")
    .map((cur) => parseInt(cur));
}
let mod = 1e9 + 7;
mod = BigInt(mod);
const pow = (num, exp, mod) => {
  if (exp === BigInt(0)) return BigInt(1);
  let x = pow(num, exp / BigInt(2), mod);
  if (exp % BigInt(2)) return (((x * x) % mod) * num) % mod;
  else return (x * x) % mod;
};
const inverse = (num, exp) => {
  return pow(BigInt(num), BigInt(exp), BigInt(mod));
};
const solve = () => {
  let t = getValue();
  while (t--) {
    let n = getValue();
    let arr = iInpArr();
    let max = -1,
      ans = 0;
    for (let i = 0; i < n; i++) {
      max = Math.max(arr[i], max);
      if (max === i + 1) ans++;
    }
    console.log(ans);
  }
};
solve();

var tests = parseInt(readline());

for (var i = 0; i < tests; i++) {
  var n = parseInt(readline());
  var arr = readline()
    .split(" ")
    .map((i) => parseInt(i));

  var el = arr[0];
  var min = el;
  var cuts = [];
  for (var j = 1; j < arr.length; j++) {
    min = Math.min(min, arr[j]);
    if (arr[j] > el) {
      cuts.push([min, el]);
      el = arr[j];
      min = el;
    }
  }
  cuts.push([min, el]);
  cuts.sort((a, b) => a[0] - b[0]);
  var sum = 1;
  var max = cuts[0][1];
  for (var j = 1; j < cuts.length; j++) {
    if (cuts[j][0] < max) max = Math.max(max, cuts[j][1]);
    else {
      sum++;
      max = cuts[j][1];
    }
  }
  print(sum);
}

"use strict";

//let startTime = Date.now();

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
    inputString += inputStdin;
});

process.stdin.on("end", (_) => {
    inputString = inputString
        .trim()
        .split("\n")
        .map((string) => {
            return string.trim();
        });

    main();
});

function readline() {
    return inputString[currentLine++];
}

function main() {
    const numOfTests = +(readline());

    for (let i=0; i<numOfTests; i++){
        const lengthOfArr = +(readline());
        const arr = readline().split(" ").map((string) => {
            return +(string);
        });

        let result = 0;

        let componentArr = [];
        let unusedComponentID = 0;

        for (let id = 0; id < lengthOfArr; id++) {
            componentArr[id] = undefined;
        }

        for (let i = 0; i < lengthOfArr; i++) {
            for (let j = lengthOfArr-1; j > 0; j--) {
                if (i < j && arr[i] > arr[j]) {
                    if (componentArr[i] === undefined && componentArr[j] === undefined) {
                        componentArr[i] = unusedComponentID;
                        componentArr[j] = unusedComponentID;
                        unusedComponentID++;
                    }
                    else if (componentArr[j] === undefined) {
                        componentArr[j] = componentArr[i];
                    }
                    else {
                        for (let n=j+1; n<lengthOfArr; n++) {
                            if (componentArr[n] === componentArr[i])
                            componentArr[n] = componentArr[j];
                        }
                        componentArr[i] = componentArr[j];
                    }
                }
            }
        }

        //console.debug(componentArr);

        for (let i = 0; i<lengthOfArr; i++) {
            if (componentArr[i] === undefined) {
                componentArr[i] = unusedComponentID;
                unusedComponentID++;
            }
            result = [... new Set(componentArr)].length;
        }

        console.log(result);
    }

//    console.log(Date.now() - startTime + " ms");
}

"use strict";

//let startTime = Date.now();

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
    inputString += inputStdin;
});

process.stdin.on("end", (_) => {
    inputString = inputString
        .trim()
        .split("\n")
        .map((string) => {
            return string.trim();
        });

    main();
});

function readline() {
    return inputString[currentLine++];
}

function main() {
    const numOfTests = +(readline());

    for (let i=0; i<numOfTests; i++){
        const lengthOfArr = +(readline());
        const arr = readline().split(" ").map((string) => {
            return +(string);
        });

        let result = 0;

        let componentArr = [];
        let unusedComponentID = 0;

        for (let id = 0; id < lengthOfArr; id++) {
            componentArr[id] = undefined;
        }

        for (let i = 0; i < lengthOfArr; i++) {
            for (let j = lengthOfArr-1; j > 0; j--) {
                if (i < j && arr[i] > arr[j]) {
                    if (componentArr[i] === undefined) {
                        componentArr[i] = unusedComponentID;
                        componentArr[j] = unusedComponentID;
                        unusedComponentID++;
                    }
                    else if (componentArr[j] === undefined) {
                        componentArr[j] = componentArr[i];
                    }
                    else {
                        for (let n=j+1; n<lengthOfArr; n++) {
                            if (componentArr[n] === componentArr[i])
                            componentArr[n] = componentArr[j];
                        }
                        componentArr[i] = componentArr[j];
                    }
                }
            }
        }

        for (let i = 0; i<lengthOfArr; i++) {
            if (componentArr[i] === undefined) {
                componentArr[i] = unusedComponentID;
                unusedComponentID++;
            }
            result = [... new Set(componentArr)].length;
        }

        console.log(result);
    }

//    console.log(Date.now() - startTime + " ms");
}

const readline = require('readline');

const rl = readline.createInterface({
    // input: require('fs').createReadStream('../input.txt')
    input: process.stdin,
    output: process.stdout
});

const it = rl[Symbol.asyncIterator]();

const main = async () => {
    const use_cases = await it.next();
    let t = use_cases.value;
    let test_case = Number(t);
    let r_t= 1;
    while(t--)
    {
        const n = Number((await it.next()).value);
        let arr = (await it.next()).value.split(' ').map( x => Number(x));
        let el = 0;
        let count = 0;
        let rem = 0;
        arr.forEach(element => {

            if(element > el)
            {
                // count++;
                rem = rem + (element - el - 1);

                el = element;
            }else{
                rem--;
            }

            if(rem === 0)
            {
                count++;
            }

        })
        // if(test_case === 100000)
        // {
        //     if(r_t === 10922)
        //     {
        //         console.log(arr);
        //     }
        // }else{
        console.log(count);
        // }
        r_t++;
    }

}
main();

const readline = require('readline');

const rl = readline.createInterface({
    // input: require('fs').createReadStream('../input.txt')
    input: process.stdin,
    output: process.stdout
});

const it = rl[Symbol.asyncIterator]();

const main = async () => {
    const use_cases = await it.next();
    let t = use_cases.value;
    let test_case = Number(t);
    let r_t= 1;
    while(t--)
    {
        const n = Number((await it.next()).value);
        let arr = (await it.next()).value.split(' ').map( x => Number(x));
        let el = 0;
        let count = 0;
        let rem = 0;
        arr.forEach(element => {

            if(element > el)
            {
                // count++;
                rem = rem + (element - el - 1);

                el = element;
            }else{
                rem--;
            }

            if(rem === 0)
            {
                count++;
            }

        })
        if(test_case === 100000)
        {
            if(r_t === 10922)
            {
                console.log(arr);
            }
        }else{
        console.log(count);
        }
        r_t++;
    }

}
main();

const readline = require('readline');

const rl = readline.createInterface({
    // input: require('fs').createReadStream('../input.txt')
    input: process.stdin,
    output: process.stdout
});

const it = rl[Symbol.asyncIterator]();

const main = async () => {
    const use_cases = await it.next();
    let t = use_cases.value;
    while(t--)
    {
        const n = Number((await it.next()).value);
        let arr = (await it.next()).value.split(' ').map( x => Number(x));
        let el = 0;
        let count = 0;
        let rem = 0;
        arr.forEach(element => {

            if(element > el)
            {
                // count++;
                rem = rem + (element - el - 1);

                el = element;
            }else{
                rem--;
            }

            if(rem === 0)
            {
                count++;
            }

        })
        console.log(count);
    }

}
main();

"use strict";

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
	inputString += inputStdin;
});

process.stdin.on("end", () => {
	inputString = inputString
		.trim()
		.split("\n")
		.map((string) => {
			return string.trim();
		});

	main();
});

function readline() {
	return inputString[currentLine++];
}

function main() {
	const testCount = +readline();

	for (let i = 0; i < testCount; i++) {
		let arrayLength = +readline();
		let perm = readline()
			.split(" ")
			.map((e) => +e);

		let n = 0;

		const graph = {};

		perm.forEach((value, index) => {
			graph[index] = { edges: [], index };
		});

		perm.forEach((value, i) => {
			perm.forEach((element, j) => {
				if (j > i && element < value) {
					graph[i].edges.push(j);
					graph[j].edges.push(i);
				}
			});
		});

		while (perm.length > 0) {
			let component = [graph[0]];
			let j = 0;
			while (component[j]) {
				const { edges } = component[j];
				edges.forEach((edge) => {
					if (component.indexOf(graph[edge]) === -1) {
						component.push(graph[edge]);
					}
				});
				j++;
			}
			n++;

			component = component.sort(({ index }, { index: index2 }) => {
				return index - index2;
			});

			for (let k = component.length - 1; k >= 0; k--) {
				let { index } = component[k];
				perm.splice(index, 1);
			}
		}

		console.log(n);
	}
}


function trim(s) {
	return s.replace(/^\s+|\s+$/gm, '');
}

function tokenize(s) {
	return trim(s).split(/\s+/);
}

function tokenizeIntegers(s) {
	var tokens = tokenize(s);
	for (var i = 0; i < tokens.length; i += 1) {
		tokens[i] = parseInt(tokens[i]);
	};
	return tokens;
}

function main() {
	var data = tokenizeIntegers(readline());
	var costs = {
		ticket: data[0],
		line: data[1],
		busesOrTrolleys: data[2],
		allLines: data[3] };

	readline();
	var busCounts = tokenizeIntegers(readline()),
		trolleyCounts = tokenizeIntegers(readline());

	var best = costs.allLines;
	best = Math.min(best, 2*costs.busesOrTrolleys);

	function bestCost(counts) {
		var total = 0;
		for (var countIndex = 0; countIndex < counts.length; ++countIndex) {
			total += Math.min(costs.line, counts[countIndex]*costs.ticket);
		}
		return total;
	}

	best = Math.min(best, costs.busesOrTrolleys +
			Math.min(bestCost(busCounts), bestCost(trolleyCounts)));
	best = Math.min(best, bestCost(busCounts) + bestCost(trolleyCounts));
	print(best);
}

main();

(function main() {
    var c = readline().split(' ').map(function(i){return parseInt(i);});
    var n = readline().split(' ').map(function(i){return parseInt(i);});
    var a = readline().split(' ').map(function(i){return Math.min(parseInt(i) * c[0], c[1]);});
    var b = readline().split(' ').map(function(i){return Math.min(parseInt(i) * c[0], c[1]);});
    var s0 = Math.min(a.reduce(function(a, b){return a + b;}), c[2]);
    var s1 = Math.min(b.reduce(function(a, b){return a + b;}), c[2]);
    print(Math.min(s0 + s1, c[3]));
})();