fn main() {
    let stdin = std::io::read_to_string(std::io::stdin().lock()).unwrap();
    let mut stdin = stdin.split_ascii_whitespace();

    unsafe {
        read!(stdin -> (n: u32, a: Vec[u32; n], q: u32, queries: Vec[(u32, u32, u32, u32); q]));
        write!(output(solve(a, queries)));
    }
}

fn solve(a: Vec<u32>, queries: Vec<(u32, u32, u32, u32)>) -> Vec<bool> {
    let mut count_of = vec![0; a.len() + 1];
    a.into_iter().for_each(|a| count_of[a as usize] += 1);
    let st = mylib::SparseTable::<S>::from(count_of);

    queries
        .into_iter()
        .map(|(l1, r1, l2, r2)| {
            if l1 <= l2 && l2 <= r2 && r2 <= r1 {
                st.range_pick_up((l1 as usize)..(l2 as usize)) >= 1
                    && st.range_pick_up((l2 as usize)..(r2 as usize + 1)) >= 2
                    && st.range_pick_up((r2 as usize + 1)..(r1 as usize + 1)) >= 1
            } else if l2 <= l1 && l1 <= r1 && r1 <= r2 {
                st.range_pick_up((l2 as usize)..(l1 as usize)) >= 1
                    && st.range_pick_up((l1 as usize)..(r1 as usize + 1)) >= 2
                    && st.range_pick_up((r1 as usize + 1)..(r2 as usize + 1)) >= 1
            } else if l1 <= l2 && l2 <= r1 && r1 <= r2 {
                st.range_pick_up((l1 as usize)..(l2 as usize)) >= 1
                    && st.range_pick_up((l2 as usize)..(r1 as usize + 1)) >= 2
                    && st.range_pick_up((r1 as usize + 1)..(r2 as usize + 1)) >= 1
            } else if l2 <= l1 && l1 <= r2 && r2 <= r1 {
                st.range_pick_up((l2 as usize)..(l1 as usize)) >= 1
                    && st.range_pick_up((l1 as usize)..(r2 as usize + 1)) >= 2
                    && st.range_pick_up((r2 as usize + 1)..(r1 as usize + 1)) >= 1
            } else {
                st.range_pick_up((l1 as usize)..(r1 as usize + 1)) >= 1
                    && st.range_pick_up((l2 as usize)..(r2 as usize + 1)) >= 1
            }
        })
        .collect()
}

fn output(ans: Vec<bool>) -> String {
    format_vec!(ans, "\n", (x) -> ("{}", match x { true => "Yes", false => "No" }))
}

struct S;

impl mylib::Monoid for S {
    type T = u32;
    const DEFAULT: Self::T = u32::MAX;
    fn op(a: &Self::T, b: &Self::T) -> Self::T {
        *a.min(b)
    }
}

mod mylib {
    pub trait Monoid {
        type T: Clone;
        const DEFAULT: Self::T;
        fn op(a: &Self::T, b: &Self::T) -> Self::T;
    }
    pub struct SparseTable<S: Monoid> {
        table: Vec<Vec<S::T>>,
    }
    impl<S: Monoid> SparseTable<S> {
        pub fn range_pick_up(&self, range: std::ops::Range<usize>) -> S::T {
            if range.start >= range.end {
                return S::DEFAULT;
            }
            let layer = (range.end - range.start).ilog2() as usize;
            S::op(
                &self.table[layer][range.start],
                &self.table[layer][range.end - (1 << layer)],
            )
        }
        #[allow(unused)]
        pub fn len(&self) -> usize {
            self.table.first().unwrap_or(&Vec::new()).len()
        }
        #[allow(unused)]
        pub fn layers(&self) -> usize {
            self.table.len()
        }
    }
    impl<S: Monoid> From<Vec<S::T>> for SparseTable<S> {
        fn from(value: Vec<S::T>) -> Self {
            let mut st = Self {
                table: Vec::<Vec<S::T>>::with_capacity(30),
            };
            if value.is_empty() {
                return st;
            }
            let n = value.len();
            st.table.push(value);
            (1_usize..)
                .take_while(|&layer| n >> layer != 0)
                .for_each(|layer| {
                    st.table.push({
                        let prev = st.table.last().unwrap();
                        (0..prev.len())
                            .map(|pos| {
                                S::op(
                                    &prev[pos],
                                    prev.get(pos + (1 << (layer - 1))).unwrap_or(&S::DEFAULT),
                                )
                            })
                            .collect()
                    })
                });
            st
        }
    }
    impl<S: Monoid> std::ops::Index<usize> for SparseTable<S> {
        type Output = S::T;
        fn index(&self, index: usize) -> &Self::Output {
            &self.table[0][index]
        }
    }
}

#[macro_export]
macro_rules! read {
    ($iter:ident -> ($v:ident : $t1:tt $([$($t2:tt)+] $({$($t3:tt)+})?)?)) => {
        let $v = read_value!($iter -> $t1 $([$($t2)+] $({$($t3)+})? )?);
    };

    ($iter:ident -> ($v:ident : $t1:tt $([$($t2:tt)+] $({$($t3:tt)+})?)? , $($r:tt)*)) => {
        read!($iter -> ($v : $t1 $([$($t2)+] $({$($t3)+})?)?));
        read!($iter -> ($($r)*));
    };
}

#[macro_export]
macro_rules! read_line {
    ($iter:ident -> ($($r:tt)*)) => {
        let cur_line = $iter.next().unwrap().unwrap();
        let mut cur_line = cur_line.split_ascii_whitespace();
        read!(cur_line -> ($($r)*))
    }
}

#[macro_export]
macro_rules! read_value {
    ($source:ident -> ($($t1:tt $([$($t2:tt)+])?),+)) => {
        ( $(read_value!($source -> $t1 $([$($t2)+])?)),* )
    };

    ($source:ident -> [ $t1:tt $([$($t3:tt)+])? ; $len:expr ]) => {
        ::std::array::from_fn::<_, $len, _>(|_| read_value!($source -> $t1 $([$($t3)+])?))
    };

    ($source:ident -> $t1:tt[ $t2:tt $([$($t3:tt)+])? ; $len:expr ]) => {
        (0..($len)).map(|_| read_value!($source -> $t2 $([$($t3)+])?)).collect::<$t1<_>>()
    };

    ($source:ident -> $t1:tt[ $t2:tt $([$($t3:tt)+])? ]) => {
        (0..(read_value!($source -> u32))).map(|_| read_value!($source -> $t2 $([$($t3)+])?)).collect::<$t1<_>>()
    };

    ($source:ident -> $t1:tt[ ($($t2:tt),+) ; $len:expr ] { $($p1:pat => ($($pos:tt),*)),* }) => {
        (0..($len)).map(|_| {
            let mut v = ($($t2::default()),+);
            v.0 = my_parser::parse_without_checking(($source).next().unwrap());
            match v.0 {
                $($p1 => {
                    $(v.$pos = my_parser::parse_without_checking(($source).next().unwrap()));*
                }),*
                _ => unreachable!(),
            }
            v
        }).collect::<$t1<_>>()
    };

    ($source:ident -> $t1:tt[ ($($t2:tt),+) ] { $($p1:pat => ($($pos:tt),*)),* }) => {
        read_value!($source -> $t1[ ($($t2),+) ; read_value!($source -> u32) ] { $($p1 => ($($pos),*)),* })
    };

    ($source:ident -> $t:ty) => {
        my_parser::parse_without_checking::<$t>(($source).next().unwrap())
    };
}

mod my_parser {
    #[allow(unused)]
    pub unsafe fn parse_without_checking<F: std::str::FromStr + Parsable>(target: &str) -> F {
        unsafe { Parsable::from_str(target) }
    }

    pub trait Parsable {
        unsafe fn from_str(s: &str) -> Self;
    }

    impl Parsable for String {
        unsafe fn from_str(s: &str) -> Self {
            Self::from(s)
        }
    }

    impl Parsable for char {
        unsafe fn from_str(s: &str) -> Self {
            s.chars().next().unwrap()
        }
    }

    macro_rules! parse_float {
        ($s:ident) => {{
            let mut iter = $s.bytes().peekable();
            let sign = match iter.peek().unwrap() {
                b'-' => {
                    iter.next();
                    -1.0
                }
                b'+' => {
                    iter.next();
                    1.0
                }
                _ => 1.0,
            };

            let mut result = 0.0;
            while let Some(cur) = iter.next() {
                if cur == b'.' {
                    break;
                }
                result = result * 10.0 + (cur - b'0') as Self;
            }
            let mut digit = 1.0;
            (result
                + iter
                    .map(|cur| {
                        digit *= 0.1;
                        digit * (cur - b'0') as Self
                    })
                    .sum::<Self>())
                * sign
        }};
    }

    impl Parsable for u8 {
        unsafe fn from_str(s: &str) -> Self {
            ((((s.bytes().fold(0, |acc, x| (acc << 8) | (x as u32)) & 0x0f0f0f0f)
                .wrapping_mul((1 << 8) + 10)
                >> 8)
                & 0x00ff00ff)
                .wrapping_mul((1 << 16) + 100)
                >> 16) as Self
        }
    }

    impl Parsable for u16 {
        unsafe fn from_str(s: &str) -> Self {
            ((((((s.bytes().fold(0, |acc, x| (acc << 8) | (x as u64)) & 0x0f0f0f0f0f0f0f0f)
                .wrapping_mul((1 << 8) + 10)
                >> 8)
                & 0x00ff00ff00ff00ff)
                .wrapping_mul((1 << 16) + 100)
                >> 16)
                & 0x0000ffff0000ffff)
                .wrapping_mul((1 << 32) + 10000)
                >> 32) as Self
        }
    }

    impl Parsable for u32 {
        unsafe fn from_str(s: &str) -> Self {
            ((((((((s.bytes().fold(0, |acc, x| (acc << 8) | (x as u128))
                & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
                .wrapping_mul((1 << 8) + 10)
                >> 8)
                & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
                .wrapping_mul((1 << 16) + 100)
                >> 16)
                & 0x0000ffff0000ffff0000ffff0000ffff)
                .wrapping_mul((1 << 32) + 10000)
                >> 32)
                & 0x00000000ffffffff00000000ffffffff)
                .wrapping_mul((1 << 64) + 100000000)
                >> 64) as Self
        }
    }

    impl Parsable for u64 {
        unsafe fn from_str(s: &str) -> Self {
            const POW_10: [u64; 17] = [
                1,
                10,
                100,
                1_000,
                10_000,
                100_000,
                1_000_000,
                10_000_000,
                100_000_000,
                1_000_000_000,
                10_000_000_000,
                100_000_000_000,
                1_000_000_000_000,
                10_000_000_000_000,
                100_000_000_000_000,
                1_000_000_000_000_000,
                10_000_000_000_000_000,
            ];
            s.as_bytes().chunks(16).fold(0, |acc, x| {
                acc * POW_10[x.len()]
                    + ((((((((x.into_iter().fold(0, |acc, &x| (acc << 8) | (x as u128))
                        & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
                        .wrapping_mul((1 << 8) + 10)
                        >> 8)
                        & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
                        .wrapping_mul((1 << 16) + 100)
                        >> 16)
                        & 0x0000ffff0000ffff0000ffff0000ffff)
                        .wrapping_mul((1 << 32) + 10000)
                        >> 32)
                        & 0x00000000ffffffff00000000ffffffff)
                        .wrapping_mul((1 << 64) + 100000000)
                        >> 64) as Self
            })
        }
    }

    impl Parsable for u128 {
        unsafe fn from_str(s: &str) -> Self {
            const POW_10: [u128; 17] = [
                1,
                10,
                100,
                1_000,
                10_000,
                100_000,
                1_000_000,
                10_000_000,
                100_000_000,
                1_000_000_000,
                10_000_000_000,
                100_000_000_000,
                1_000_000_000_000,
                10_000_000_000_000,
                100_000_000_000_000,
                1_000_000_000_000_000,
                10_000_000_000_000_000,
            ];
            s.as_bytes().chunks(16).fold(0, |acc, x| {
                acc * POW_10[x.len()]
                    + ((((((((x.into_iter().fold(0, |acc, &x| (acc << 8) | (x as u128))
                        & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
                        .wrapping_mul((1 << 8) + 10)
                        >> 8)
                        & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
                        .wrapping_mul((1 << 16) + 100)
                        >> 16)
                        & 0x0000ffff0000ffff0000ffff0000ffff)
                        .wrapping_mul((1 << 32) + 10000)
                        >> 32)
                        & 0x00000000ffffffff00000000ffffffff)
                        .wrapping_mul((1 << 64) + 100000000)
                        >> 64) as Self
            })
        }
    }

    impl Parsable for i8 {
        unsafe fn from_str(s: &str) -> Self {
            ((((((s
                .bytes()
                .skip(match s.as_bytes()[0].is_ascii_digit() {
                    true => 0,
                    false => 1,
                })
                .fold(0, |acc, x| (acc << 8) | (x as u32))
                & 0x0f0f0f0f)
                .wrapping_mul((1 << 8) + 10)
                >> 8)
                & 0x00ff00ff)
                .wrapping_mul((1 << 16) + 100)
                >> 16) as i32)
                * match s.as_bytes()[0] == b'-' {
                    true => -1,
                    false => 1,
                }) as Self
        }
    }

    impl Parsable for i16 {
        unsafe fn from_str(s: &str) -> Self {
            ((((((((s
                .bytes()
                .skip(match s.as_bytes()[0].is_ascii_digit() {
                    true => 0,
                    false => 1,
                })
                .fold(0, |acc, x| (acc << 8) | (x as u64))
                & 0x0f0f0f0f0f0f0f0f)
                .wrapping_mul((1 << 8) + 10)
                >> 8)
                & 0x00ff00ff00ff00ff)
                .wrapping_mul((1 << 16) + 100)
                >> 16)
                & 0x0000ffff0000ffff)
                .wrapping_mul((1 << 32) + 10000)
                >> 32) as i64)
                * match s.as_bytes()[0] == b'-' {
                    true => -1,
                    false => 1,
                }) as Self
        }
    }

    impl Parsable for i32 {
        unsafe fn from_str(s: &str) -> Self {
            ((((((((((s
                .bytes()
                .skip(match s.as_bytes()[0].is_ascii_digit() {
                    true => 0,
                    false => 1,
                })
                .fold(0, |acc, x| (acc << 8) | (x as u128))
                & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
                .wrapping_mul((1 << 8) + 10)
                >> 8)
                & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
                .wrapping_mul((1 << 16) + 100)
                >> 16)
                & 0x0000ffff0000ffff0000ffff0000ffff)
                .wrapping_mul((1 << 32) + 10000)
                >> 32)
                & 0x00000000ffffffff00000000ffffffff)
                .wrapping_mul((1 << 64) + 100000000)
                >> 64) as i128)
                * match s.as_bytes()[0] == b'-' {
                    true => -1,
                    false => 1,
                }) as Self
        }
    }

    impl Parsable for i64 {
        unsafe fn from_str(s: &str) -> Self {
            const POW_10: [u64; 17] = [
                1,
                10,
                100,
                1_000,
                10_000,
                100_000,
                1_000_000,
                10_000_000,
                100_000_000,
                1_000_000_000,
                10_000_000_000,
                100_000_000_000,
                1_000_000_000_000,
                10_000_000_000_000,
                100_000_000_000_000,
                1_000_000_000_000_000,
                10_000_000_000_000_000,
            ];
            let skip = match s.as_bytes()[0].is_ascii_digit() {
                true => 0,
                false => 1,
            };
            ((s.as_bytes()[skip..].chunks(16).fold(0, |acc, x| {
                acc * POW_10[x.len()]
                    + ((((((((x.into_iter().fold(0, |acc, &x| (acc << 8) | (x as u128))
                        & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
                        .wrapping_mul((1 << 8) + 10)
                        >> 8)
                        & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
                        .wrapping_mul((1 << 16) + 100)
                        >> 16)
                        & 0x0000ffff0000ffff0000ffff0000ffff)
                        .wrapping_mul((1 << 32) + 10000)
                        >> 32)
                        & 0x00000000ffffffff00000000ffffffff)
                        .wrapping_mul((1 << 64) + 100000000)
                        >> 64) as u64
            }) as i64)
                * match s.as_bytes()[0] == b'-' {
                    true => -1,
                    false => 1,
                }) as Self
        }
    }

    impl Parsable for i128 {
        unsafe fn from_str(s: &str) -> Self {
            const POW_10: [u128; 17] = [
                1,
                10,
                100,
                1_000,
                10_000,
                100_000,
                1_000_000,
                10_000_000,
                100_000_000,
                1_000_000_000,
                10_000_000_000,
                100_000_000_000,
                1_000_000_000_000,
                10_000_000_000_000,
                100_000_000_000_000,
                1_000_000_000_000_000,
                10_000_000_000_000_000,
            ];
            let skip = match s.as_bytes()[0].is_ascii_digit() {
                true => 0,
                false => 1,
            };
            ((s.as_bytes()[skip..].chunks(16).fold(0, |acc, x| {
                acc * POW_10[x.len()]
                    + ((((((((x.into_iter().fold(0, |acc, &x| (acc << 8) | (x as u128))
                        & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
                        .wrapping_mul((1 << 8) + 10)
                        >> 8)
                        & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
                        .wrapping_mul((1 << 16) + 100)
                        >> 16)
                        & 0x0000ffff0000ffff0000ffff0000ffff)
                        .wrapping_mul((1 << 32) + 10000)
                        >> 32)
                        & 0x00000000ffffffff00000000ffffffff)
                        .wrapping_mul((1 << 64) + 100000000)
                        >> 64)
            }) as i128)
                * match s.as_bytes()[0] == b'-' {
                    true => -1,
                    false => 1,
                }) as Self
        }
    }

    impl Parsable for f32 {
        unsafe fn from_str(s: &str) -> Self {
            parse_float!(s)
        }
    }

    impl Parsable for f64 {
        unsafe fn from_str(s: &str) -> Self {
            parse_float!(s)
        }
    }
}

#[macro_export]
macro_rules! write {
    ($out:expr) => {{
        use std::io::Write;
        std::io::stdout()
            .lock()
            .write_all(($out).as_bytes())
            .unwrap();
    }};
}

#[macro_export]
macro_rules! format_iter {
    ($i:expr, $sep:expr, ($($elem:ident),+) -> ($form:expr $(, $ex:expr)*)) => {{
        #[allow(unused_parens)]
        let ($($elem),+) = i.next().unwrap();
        #[allow(unused_parens)]
        $i.fold(std::format!($form $(, $ex)*), |mut acc, ($($elem),+)| {
            use std::fmt::Write;
            acc.push_str($sep);
            std::write!(&mut acc, $form $(, $ex)*).unwrap();
            acc
        })
    }}
}

#[macro_export]
macro_rules! format_vec {
    ($v:expr, $sep:expr, ($($elem:ident),+) -> ($form:expr $(, $ex:expr)*)) => {{
        if $v.is_empty() {
            String::new()
        } else {
            let mut iter = $v.into_iter();
            #[allow(unused_parens)]
            let ($($elem),+) = iter.next().unwrap();
            #[allow(unused_parens)]
            iter.fold(std::format!($form $(, $ex)*), |mut acc, ($($elem),+)| {
                use std::fmt::Write;
                acc.push_str($sep);
                std::write!(&mut acc, $form $(, $ex)*).unwrap();
                acc
            })
        }
    }}
}

#[macro_export]
macro_rules! format_vec_vec {
    ($v:expr, $sep1:expr, $sep2:expr, ($($elem:ident),+) -> ($form:expr $(, $ex:expr)*)) => {{
        let mut iter = $v.into_iter();
        let v_first = iter.next().unwrap();
        #[allow(unused_parens)]
        iter.fold(format_vec!(v_first, $sep2, ($($elem),+) -> ($form $(, $ex)*)), |mut acc, v| {
            use std::fmt::Write;
            acc.push_str($sep1);
            if !v.is_empty() {
                let mut iter_inner = v.into_iter();
                #[allow(unused_parens)]
                let ($($elem),+) = iter_inner.next().unwrap();
                std::write!(&mut acc, $form $(, $ex)*).unwrap();
                iter_inner.fold(acc, |mut acc, ($($elem),+)| {
                    acc.push_str($sep2);
                    std::write!(&mut acc, $form $(, $ex)*).unwrap();
                    acc
                })
            }
        })
    }}
}