Problem:
Score : 900 points

Problem Statement

Takahashi has an N \times M grid, with N horizontal rows and M vertical columns.
Determine if we can place A 1 \times 2 tiles (1 vertical, 2 horizontal) and B 2 \times 1 tiles (2 vertical, 1 horizontal) satisfying the following conditions, and construct one arrangement of the tiles if it is possible:

All the tiles must be placed on the grid.

Tiles must not stick out of the grid, and no two different tiles may intersect.

Neither the grid nor the tiles may be rotated.

Every tile completely covers exactly two squares.

Constraints

1 \leq N,M \leq 1000

0 \leq A,B \leq 500000

N, M, A and B are integers.

Input

Input is given from Standard Input in the following format:

N M A B

Output

If it is impossible to place all the tiles, print NO.
Otherwise, print the following:

YES
c_{11}...c_{1M}
:
c_{N1}...c_{NM}

Here, c_{ij} must be one of the following characters: ., <, >, ^ and v. Represent an arrangement by using each of these characters as follows:

When c_{ij} is ., it indicates that the square at the i-th row and j-th column is empty;

When c_{ij} is <, it indicates that the square at the i-th row and j-th column is covered by the left half of a 1 \times 2 tile;

When c_{ij} is >, it indicates that the square at the i-th row and j-th column is covered by the right half of a 1 \times 2 tile;

When c_{ij} is ^, it indicates that the square at the i-th row and j-th column is covered by the top half of a 2 \times 1 tile;

When c_{ij} is v, it indicates that the square at the i-th row and j-th column is covered by the bottom half of a 2 \times 1 tile.

Sample Input 1

3 4 4 2

Sample Output 1

YES
<><>
^<>^
v<>v

This is one example of a way to place four 1 \times 2 tiles and three 2 \times 1 tiles on a 3 \times 4 grid.

Sample Input 2

4 5 5 3

Sample Output 2

YES
<>..^
^.<>v
v<>.^
<><>v

Sample Input 3

7 9 20 20

Sample Output 3

NO

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

fn putA(a: &mut usize, (x, y): (usize, usize), grid: &mut Vec<Vec<char>>) {
    if *a > 0 {
        grid[y][x] = '<';
        grid[y][x + 1] = '>';
        *a -= 1;
    }
}
fn putB(b: &mut usize, (x, y): (usize, usize), grid: &mut Vec<Vec<char>>) {
    if *b > 0 {
        grid[y][x] = '^';
        grid[y + 1][x] = 'v';
        *b -= 1;
    }
}

fn main() {
    let (mut h, mut w, mut a, mut b): (usize, usize, usize, usize) = readln();
    let mut grid = vec![vec!['.'; w]; h];
    if h % 2 != 0 {
        for i in 0..w / 2 {
            putA(&mut a, (i * 2, h - 1), &mut grid);
        }
    }
    if w % 2 != 0 {
        for i in 0..h / 2 {
            putB(&mut b, (w - 1, i * 2), &mut grid);
        }
    }
    for y in 0..h {
        for x in 0..w {
            if y + 1 < h && x + 1 < w && y % 2 == 0 && x % 2 == 0 {
                if a > b {
                    putA(&mut a, (x, y), &mut grid);
                    putA(&mut a, (x, y + 1), &mut grid);
                } else {
                    putB(&mut b, (x, y), &mut grid);
                    putB(&mut b, (x + 1, y), &mut grid);
                }
            }
        }
    }
    if a == 0 && b == 0 {
        println!("YES");
        for y in 0..h {
            for x in 0..w {
                print!("{}", grid[y][x]);
            }
            println!("");
        }
    } else {
        println!("NO");
    }
}

#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet, VecDeque};

pub trait FromLn {
    fn fromln(s: &str) -> Self;
}
pub fn readln<T: FromLn>() -> T {
    let mut buf = String::new();
    let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
    T::fromln(buf.trim())
}
pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
    let mut vs = vec![];
    for _ in 0..n {
        vs.push(readln());
    }
    vs
}
macro_rules! fromln_primitives {
    ($($t:ty),*) => { $(
        impl FromLn for $t {
            fn fromln(s: &str) -> $t {
                s.parse().unwrap()
            }
        }
    )* }
}
fromln_primitives!(
    String,
    bool,
    f32,
    f64,
    isize,
    i8,
    i16,
    i32,
    i64,
    usize,
    u8,
    u16,
    u32,
    u64
);
impl<T> FromLn for Vec<T>
where
    T: FromLn,
{
    fn fromln(s: &str) -> Vec<T> {
        s.split_whitespace().map(T::fromln).collect()
    }
}
impl FromLn for Vec<char> {
    fn fromln(s: &str) -> Vec<char> {
        s.chars().collect()
    }
}
macro_rules! fromln_tuple {
    ($($t:ident),*) => {
        impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {
            fn fromln(s: &str) -> ($($t),*) {
                let mut it = s.split_whitespace();
                let t = ($($t::fromln(it.next().unwrap())),*);
                assert_eq!(it.next(), None);
                t
            }
        }
    }
}
fromln_tuple!(A, B);
fromln_tuple!(A, B, C);
fromln_tuple!(A, B, C, D);
fromln_tuple!(A, B, C, D, E);
fromln_tuple!(A, B, C, D, E, F);
mod comp {
    pub mod math {
        pub mod comb {
            use super::mint::{Mint, MOD};
            pub struct Comb {
                fact: Vec<Mint>,
                factinv: Vec<Mint>,
            }
            impl Comb {
                pub fn new(n: usize) -> Comb {
                    let mut fact: Vec<Mint> = vec![0.into(); n + 1];
                    let mut factinv: Vec<Mint> = vec![0.into(); n + 1];
                    fact[0] = 1.into();
                    for i in 0..n {
                        fact[i + 1] = fact[i] * (i + 1);
                    }
                    factinv[n] = fact[n].inv();
                    for i in (0..n).rev() {
                        factinv[i] = factinv[i + 1] * (i + 1);
                    }
                    Comb {
                        fact: fact,
                        factinv: factinv,
                    }
                }
                pub fn fact(&self, n: u64) -> Mint {
                    if let Some(x) = self.fact.get(n as usize) {
                        *x
                    } else if n >= MOD as u64 {
                        Mint::from(0)
                    } else {
                        let base = 1000000;
                        let p = n / base;
                        let mut res = PRECALC_FACT[p as usize].into();
                        for a in (p * base + 1)..(n + 1) {
                            res *= a;
                        }
                        res
                    }
                }
                pub fn factinv(&self, n: u64) -> Mint {
                    if let Some(x) = self.factinv.get(n as usize) {
                        *x
                    } else {
                        self.fact(n).inv()
                    }
                }
                pub fn perm(&self, n: u64, r: u64) -> Mint {
                    if n >= r {
                        self.fact(n) * self.factinv((n - r) as u64)
                    } else {
                        0.into()
                    }
                }
                pub fn comb(&self, n: u64, r: u64) -> Mint {
                    let m = MOD as u64;
                    if n >= m {
                        self.comb(n % m, r % m) * self.comb(n / m, r / m)
                    } else if n >= r {
                        self.fact(n) * self.factinv(n - r) * self.factinv(r)
                    } else {
                        Mint::from(0)
                    }
                }
                pub fn multi_comb(&self, n: u64, r: u64) -> Mint {
                    if r == 0 {
                        Mint::from(1)
                    } else {
                        self.comb(n + r - 1, r)
                    }
                }
            }
            static PRECALC_FACT: &'static [u32] = &[
                1, 641102369, 578095319, 5832229, 259081142, 974067448, 316220877, 690120224,
                251368199, 980250487, 682498929, 134623568, 95936601, 933097914, 167332441,
                598816162, 336060741, 248744620, 626497524, 288843364, 491101308, 245341950,
                565768255, 246899319, 968999, 586350670, 638587686, 881746146, 19426633, 850500036,
                76479948, 268124147, 842267748, 886294336, 485348706, 463847391, 544075857,
                898187927, 798967520, 82926604, 723816384, 156530778, 721996174, 299085602,
                323604647, 172827403, 398699886, 530389102, 294587621, 813805606, 67347853,
                497478507, 196447201, 722054885, 228338256, 407719831, 762479457, 746536789,
                811667359, 778773518, 27368307, 438371670, 59469516, 5974669, 766196482, 606322308,
                86609485, 889750731, 340941507, 371263376, 625544428, 788878910, 808412394,
                996952918, 585237443, 1669644, 361786913, 480748381, 595143852, 837229828,
                199888908, 526807168, 579691190, 145404005, 459188207, 534491822, 439729802,
                840398449, 899297830, 235861787, 888050723, 656116726, 736550105, 440902696,
                85990869, 884343068, 56305184, 973478770, 168891766, 804805577, 927880474,
                876297919, 934814019, 676405347, 567277637, 112249297, 44930135, 39417871,
                47401357, 108819476, 281863274, 60168088, 692636218, 432775082, 14235602,
                770511792, 400295761, 697066277, 421835306, 220108638, 661224977, 261799937,
                168203998, 802214249, 544064410, 935080803, 583967898, 211768084, 751231582,
                972424306, 623534362, 335160196, 243276029, 554749550, 60050552, 797848181,
                395891998, 172428290, 159554990, 887420150, 970055531, 250388809, 487998999,
                856259313, 82104855, 232253360, 513365505, 244109365, 1559745, 695345956,
                261384175, 849009131, 323214113, 747664143, 444090941, 659224434, 80729842,
                570033864, 664989237, 827348878, 195888993, 576798521, 457882808, 731551699,
                212938473, 509096183, 827544702, 678320208, 677711203, 289752035, 66404266,
                555972231, 195290384, 97136305, 349551356, 785113347, 83489485, 66247239, 52167191,
                307390891, 547665832, 143066173, 350016754, 917404120, 296269301, 996122673,
                23015220, 602139210, 748566338, 187348575, 109838563, 574053420, 105574531,
                304173654, 542432219, 34538816, 325636655, 437843114, 630621321, 26853683,
                933245637, 616368450, 238971581, 511371690, 557301633, 911398531, 848952161,
                958992544, 925152039, 914456118, 724691727, 636817583, 238087006, 946237212,
                910291942, 114985663, 492237273, 450387329, 834860913, 763017204, 368925948,
                475812562, 740594930, 45060610, 806047532, 464456846, 172115341, 75307702,
                116261993, 562519302, 268838846, 173784895, 243624360, 61570384, 481661251,
                938269070, 95182730, 91068149, 115435332, 495022305, 136026497, 506496856,
                710729672, 113570024, 366384665, 564758715, 270239666, 277118392, 79874094,
                702807165, 112390913, 730341625, 103056890, 677948390, 339464594, 167240465,
                108312174, 839079953, 479334442, 271788964, 135498044, 277717575, 591048681,
                811637561, 353339603, 889410460, 839849206, 192345193, 736265527, 316439118,
                217544623, 788132977, 618898635, 183011467, 380858207, 996097969, 898554793,
                335353644, 54062950, 611251733, 419363534, 965429853, 160398980, 151319402,
                990918946, 607730875, 450718279, 173539388, 648991369, 970937898, 500780548,
                780122909, 39052406, 276894233, 460373282, 651081062, 461415770, 358700839,
                643638805, 560006119, 668123525, 686692315, 673464765, 957633609, 199866123,
                563432246, 841799766, 385330357, 504962686, 954061253, 128487469, 685707545,
                299172297, 717975101, 577786541, 318951960, 773206631, 306832604, 204355779,
                573592106, 30977140, 450398100, 363172638, 258379324, 472935553, 93940075,
                587220627, 776264326, 793270300, 291733496, 522049725, 579995261, 335416359,
                142946099, 472012302, 559947225, 332139472, 499377092, 464599136, 164752359,
                309058615, 86117128, 580204973, 563781682, 954840109, 624577416, 895609896,
                888287558, 836813268, 926036911, 386027524, 184419613, 724205533, 403351886,
                715247054, 716986954, 830567832, 383388563, 68409439, 6734065, 189239124, 68322490,
                943653305, 405755338, 811056092, 179518046, 825132993, 343807435, 985084650,
                868553027, 148528617, 160684257, 882148737, 591915968, 701445829, 529726489,
                302177126, 974886682, 241107368, 798830099, 940567523, 11633075, 325334066,
                346091869, 115312728, 473718967, 218129285, 878471898, 180002392, 699739374,
                917084264, 856859395, 435327356, 808651347, 421623838, 105419548, 59883031,
                322487421, 79716267, 715317963, 429277690, 398078032, 316486674, 384843585,
                940338439, 937409008, 940524812, 947549662, 833550543, 593524514, 996164327,
                987314628, 697611981, 636177449, 274192146, 418537348, 925347821, 952831975,
                893732627, 1277567, 358655417, 141866945, 581830879, 987597705, 347046911,
                775305697, 125354499, 951540811, 247662371, 343043237, 568392357, 997474832,
                209244402, 380480118, 149586983, 392838702, 309134554, 990779998, 263053337,
                325362513, 780072518, 551028176, 990826116, 989944961, 155569943, 596737944,
                711553356, 268844715, 451373308, 379404150, 462639908, 961812918, 654611901,
                382776490, 41815820, 843321396, 675258797, 845583555, 934281721, 741114145,
                275105629, 666247477, 325912072, 526131620, 252551589, 432030917, 554917439,
                818036959, 754363835, 795190182, 909210595, 278704903, 719566487, 628514947,
                424989675, 321685608, 50590510, 832069712, 198768464, 702004730, 99199382,
                707469729, 747407118, 302020341, 497196934, 5003231, 726997875, 382617671,
                296229203, 183888367, 703397904, 552133875, 732868367, 350095207, 26031303,
                863250534, 216665960, 561745549, 352946234, 784139777, 733333339, 503105966,
                459878625, 803187381, 16634739, 180898306, 68718097, 985594252, 404206040,
                749724532, 97830135, 611751357, 31131935, 662741752, 864326453, 864869025,
                167831173, 559214642, 718498895, 91352335, 608823837, 473379392, 385388084,
                152267158, 681756977, 46819124, 313132653, 56547945, 442795120, 796616594,
                256141983, 152028387, 636578562, 385377759, 553033642, 491415383, 919273670,
                996049638, 326686486, 160150665, 141827977, 540818053, 693305776, 593938674,
                186576440, 688809790, 565456578, 749296077, 519397500, 551096742, 696628828,
                775025061, 370732451, 164246193, 915265013, 457469634, 923043932, 912368644,
                777901604, 464118005, 637939935, 956856710, 490676632, 453019482, 462528877,
                502297454, 798895521, 100498586, 699767918, 849974789, 811575797, 438952959,
                606870929, 907720182, 179111720, 48053248, 508038818, 811944661, 752550134,
                401382061, 848924691, 764368449, 34629406, 529840945, 435904287, 26011548,
                208184231, 446477394, 206330671, 366033520, 131772368, 185646898, 648711554,
                472759660, 523696723, 271198437, 25058942, 859369491, 817928963, 330711333,
                724464507, 437605233, 701453022, 626663115, 281230685, 510650790, 596949867,
                295726547, 303076380, 465070856, 272814771, 538771609, 48824684, 951279549,
                939889684, 564188856, 48527183, 201307702, 484458461, 861754542, 326159309,
                181594759, 668422905, 286273596, 965656187, 44135644, 359960756, 936229527,
                407934361, 267193060, 456152084, 459116722, 124804049, 262322489, 920251227,
                816929577, 483924582, 151834896, 167087470, 490222511, 903466878, 361583925,
                368114731, 339383292, 388728584, 218107212, 249153339, 909458706, 322908524,
                202649964, 92255682, 573074791, 15570863, 94331513, 744158074, 196345098,
                334326205, 9416035, 98349682, 882121662, 769795511, 231988936, 888146074,
                137603545, 582627184, 407518072, 919419361, 909433461, 986708498, 310317874,
                373745190, 263645931, 256853930, 876379959, 702823274, 147050765, 308186532,
                175504139, 180350107, 797736554, 606241871, 384547635, 273712630, 586444655,
                682189174, 666493603, 946867127, 819114541, 502371023, 261970285, 825871994,
                126925175, 701506133, 314738056, 341779962, 561011609, 815463367, 46765164,
                49187570, 188054995, 957939114, 64814326, 933376898, 329837066, 338121343,
                765215899, 869630152, 978119194, 632627667, 975266085, 435887178, 282092463,
                129621197, 758245605, 827722926, 201339230, 918513230, 322096036, 547838438,
                985546115, 852304035, 593090119, 689189630, 555842733, 567033437, 469928208,
                212842957, 117842065, 404149413, 155133422, 663307737, 208761293, 206282795,
                717946122, 488906585, 414236650, 280700600, 962670136, 534279149, 214569244,
                375297772, 811053196, 922377372, 289594327, 219932130, 211487466, 701050258,
                398782410, 863002719, 27236531, 217598709, 375472836, 810551911, 178598958,
                247844667, 676526196, 812283640, 863066876, 857241854, 113917835, 624148346,
                726089763, 564827277, 826300950, 478982047, 439411911, 454039189, 633292726,
                48562889, 802100365, 671734977, 945204804, 508831870, 398781902, 897162044,
                644050694, 892168027, 828883117, 277714559, 713448377, 624500515, 590098114,
                808691930, 514359662, 895205045, 715264908, 628829100, 484492064, 919717789,
                513196123, 748510389, 403652653, 574455974, 77123823, 172096141, 819801784,
                581418893, 15655126, 15391652, 875641535, 203191898, 264582598, 880691101,
                907800444, 986598821, 340030191, 264688936, 369832433, 785804644, 842065079,
                423951674, 663560047, 696623384, 496709826, 161960209, 331910086, 541120825,
                951524114, 841656666, 162683802, 629786193, 190395535, 269571439, 832671304,
                76770272, 341080135, 421943723, 494210290, 751040886, 317076664, 672850561,
                72482816, 493689107, 135625240, 100228913, 684748812, 639655136, 906233141,
                929893103, 277813439, 814362881, 562608724, 406024012, 885537778, 10065330,
                60625018, 983737173, 60517502, 551060742, 804930491, 823845496, 727416538,
                946421040, 678171399, 842203531, 175638827, 894247956, 538609927, 885362182,
                946464959, 116667533, 749816133, 241427979, 871117927, 281804989, 163928347,
                563796647, 640266394, 774625892, 59342705, 256473217, 674115061, 918860977,
                322633051, 753513874, 393556719, 304644842, 767372800, 161362528, 754787150,
                627655552, 677395736, 799289297, 846650652, 816701166, 687265514, 787113234,
                358757251, 701220427, 607715125, 245795606, 600624983, 10475577, 728620948,
                759404319, 36292292, 491466901, 22556579, 114495791, 647630109, 586445753,
                482254337, 718623833, 763514207, 66547751, 953634340, 351472920, 308474522,
                494166907, 634359666, 172114298, 865440961, 364380585, 921648059, 965683742,
                260466949, 117483873, 962540888, 237120480, 620531822, 193781724, 213092254,
                107141741, 602742426, 793307102, 756154604, 236455213, 362928234, 14162538,
                753042874, 778983779, 25977209, 49389215, 698308420, 859637374, 49031023,
                713258160, 737331920, 923333660, 804861409, 83868974, 682873215, 217298111,
                883278906, 176966527, 954913, 105359006, 390019735, 10430738, 706334445, 315103615,
                567473423, 708233401, 48160594, 946149627, 346966053, 281329488, 462880311,
                31503476, 185438078, 965785236, 992656683, 916291845, 881482632, 899946391,
                321900901, 512634493, 303338827, 121000338, 967284733, 492741665, 152233223,
                165393390, 680128316, 917041303, 532702135, 741626808, 496442755, 536841269,
                131384366, 377329025, 301196854, 859917803, 676511002, 373451745, 847645126,
                823495900, 576368335, 73146164, 954958912, 847549272, 241289571, 646654592,
                216046746, 205951465, 3258987, 780882948, 822439091, 598245292, 869544707,
                698611116,
            ];
            #[cfg(test)]
            mod tests {
                use super::*;
                #[test]
                fn test_simple() {
                    let c = Comb::new(100);
                    assert_eq!(Mint::from(336), c.perm(8, 3));
                    assert_eq!(Mint::from(56), c.comb(8, 3));
                    assert_eq!(Mint::from(10), c.multi_comb(3, 3));
                }
                #[test]
                fn test_fact() {
                    let c = Comb::new(100);
                    let p = 8721234;
                    let mut f = Mint::from(1);
                    for i in 1..(p + 1) {
                        f *= i;
                    }
                    assert_eq!(f, c.fact(p));
                }
            }
        }
        pub mod mint {
            use std;
            pub const MOD: u32 = 1000000007;
            #[derive(Debug, Copy, Clone, Eq)]
            pub struct Mint {
                val: u32,
            }
            impl<T: Into<Mint>> std::ops::Add<T> for Mint {
                type Output = Mint;
                fn add(self, other: T) -> Mint {
                    let nval = self.val + other.into().val;
                    Mint {
                        val: if nval >= MOD { nval - MOD } else { nval },
                    }
                }
            }
            impl<T: Into<Mint>> std::ops::Sub<T> for Mint {
                type Output = Mint;
                fn sub(self, other: T) -> Mint {
                    let nval = self.val + MOD - other.into().val;
                    Mint {
                        val: if nval >= MOD { nval - MOD } else { nval },
                    }
                }
            }
            impl<T: Into<Mint>> std::ops::Mul<T> for Mint {
                type Output = Mint;
                fn mul(self, other: T) -> Mint {
                    let nval = self.val as u64 * other.into().val as u64;
                    Mint {
                        val: (nval % (MOD as u64)) as u32,
                    }
                }
            }
            impl<T: Into<Mint>> std::ops::Div<T> for Mint {
                type Output = Mint;
                fn div(self, other: T) -> Mint {
                    self * other.into().inv()
                }
            }
            impl Mint {
                pub fn inv(self) -> Mint {
                    let mut a = self.val as i32;
                    let mut b = MOD as i32;
                    let mut u = 1 as i32;
                    let mut v = 0 as i32;
                    while b != 0 {
                        let t = a / b;
                        a -= t * b;
                        std::mem::swap(&mut a, &mut b);
                        u -= t * v;
                        std::mem::swap(&mut u, &mut v);
                    }
                    Mint {
                        val: if u < 0 { u + MOD as i32 } else { u } as u32,
                    }
                }
            }
            impl PartialEq for Mint {
                fn eq(&self, other: &Mint) -> bool {
                    self.val == other.val
                }
            }
            impl std::fmt::Display for Mint {
                fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                    self.val.fmt(f)
                }
            }
            macro_rules! impl_signed_mint(( $ ( $ t : ty ) * ) => (
                                      $ (
                                      impl From < $ t > for Mint {
                                      # [ inline ] fn from ( x : $ t ) -> Mint
                                      {
                                      let t = ( x as i64 ) % ( MOD as i64 ) ;
                                      if x >= 0 { Mint { val : t as u32 } }
                                      else {
                                      Mint { val : ( MOD as i64 + t ) as u32 }
                                      } } } ) * ));
            macro_rules! impl_unsigned_mint(( $ ( $ t : ty ) * ) => (
                                        $ (
                                        impl From < $ t > for Mint {
                                        # [ inline ] fn from ( x : $ t ) ->
                                        Mint {
                                        let t = x as u64 % MOD as u64 ; Mint {
                                        val : t as u32 } } } ) * ));
            impl_signed_mint! (i8 i16 i32 i64 isize);
            impl_unsigned_mint! (u8 u16 u32 u64 usize);
            impl<T: Into<Mint>> std::ops::AddAssign<T> for Mint {
                fn add_assign(&mut self, other: T) {
                    *self = *self + other.into();
                }
            }
            impl<T: Into<Mint>> std::ops::SubAssign<T> for Mint {
                fn sub_assign(&mut self, other: T) {
                    *self = *self - other.into();
                }
            }
            impl<T: Into<Mint>> std::ops::MulAssign<T> for Mint {
                fn mul_assign(&mut self, other: T) {
                    *self = *self * other.into();
                }
            }
            impl<T: Into<Mint>> std::ops::DivAssign<T> for Mint {
                fn div_assign(&mut self, other: T) {
                    *self = *self / other.into();
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                #[test]
                fn test_simple() {
                    let a: Mint = Mint::from(3);
                    let b: Mint = Mint::from(1000000000);
                    assert_eq!(Mint::from(3000000000u64 % MOD as u64), a * b);
                }
            }
        }
        pub mod prime {
            pub fn is_prime(n: u64) -> bool {
                const HINT: &'static [u64] = &[2];
                const WITNESSES: &'static [(u64, &'static [u64])] = &[
                    (2046, HINT),
                    (1373652, &[2, 3]),
                    (9080190, &[31, 73]),
                    (25326000, &[2, 3, 5]),
                    (4759123140, &[2, 7, 61]),
                    (1112004669632, &[2, 13, 23, 1662803]),
                    (2152302898746, &[2, 3, 5, 7, 11]),
                    (3474749660382, &[2, 3, 5, 7, 11, 13]),
                    (341550071728320, &[2, 3, 5, 7, 11, 13, 17]),
                    (18446744073709551615, &[2, 3, 5, 7, 11, 13, 17, 19, 23]),
                ];
                if n % 2 == 0 {
                    return n == 2;
                }
                if n == 1 {
                    return false;
                }
                let mut d = n - 1;
                let mut s = 0;
                while d % 2 == 0 {
                    d /= 2;
                    s += 1
                }
                let witnesses = WITNESSES
                    .iter()
                    .find(|&&(hi, _)| hi >= n)
                    .map(|&(_, wtnss)| wtnss)
                    .unwrap();
                'next_witness: for &a in witnesses.iter() {
                    let mut power = mod_exp(a, d, n);
                    assert!(power < n);
                    if power == 1 || power == n - 1 {
                        continue 'next_witness;
                    }
                    for _r in 0..s {
                        power = mod_sqr(power, n);
                        assert!(power < n);
                        if power == 1 {
                            return false;
                        }
                        if power == n - 1 {
                            continue 'next_witness;
                        }
                    }
                    return false;
                }
                true
            }
            #[derive(Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Debug)]
            struct U128 {
                hi: u64,
                lo: u64,
            }
            fn modulo(mut a: U128, m: u64) -> u64 {
                if a.hi >= m {
                    a.hi -= (a.hi / m) * m;
                }
                let mut x = a.hi;
                let mut y = a.lo;
                for _ in 0..64 {
                    let t = (x as i64 >> 63) as u64;
                    x = (x << 1) | (y >> 63);
                    y <<= 1;
                    if (x | t) >= m {
                        x = x.wrapping_sub(m);
                        y += 1;
                    }
                }
                x
            }
            fn mul128(u: u64, v: u64) -> U128 {
                let u1 = u >> 32;
                let u0 = u & (!0 >> 32);
                let v1 = v >> 32;
                let v0 = v & (!0 >> 32);
                let t = u0 * v0;
                let w0 = t & (!0 >> 32);
                let k = t >> 32;
                let t = u1 * v0 + k;
                let w1 = t & (!0 >> 32);
                let w2 = t >> 32;
                let t = u0 * v1 + w1;
                let k = t >> 32;
                U128 {
                    lo: (t << 32) + w0,
                    hi: u1 * v1 + w2 + k,
                }
            }
            fn mod_mul_(a: u64, b: u64, m: u64) -> u64 {
                modulo(mul128(a, b), m)
            }
            fn mod_mul(a: u64, b: u64, m: u64) -> u64 {
                match a.checked_mul(b) {
                    Some(r) => if r >= m {
                        r % m
                    } else {
                        r
                    },
                    None => mod_mul_(a, b, m),
                }
            }
            fn mod_sqr(a: u64, m: u64) -> u64 {
                if a < (1 << 32) {
                    let r = a * a;
                    if r >= m {
                        r % m
                    } else {
                        r
                    }
                } else {
                    mod_mul_(a, a, m)
                }
            }
            fn mod_exp(mut x: u64, mut d: u64, n: u64) -> u64 {
                let mut ret: u64 = 1;
                while d != 0 {
                    if d % 2 == 1 {
                        ret = mod_mul(ret, x, n)
                    }
                    d /= 2;
                    x = mod_sqr(x, n);
                }
                ret
            }
        }
    }
    pub mod data_structure {
        pub mod bit {
            pub struct BIT {
                tree: Vec<i64>,
            }
            pub struct BITRange {
                bit0: BIT,
                bit1: BIT,
            }
            impl BIT {
                pub fn new(n: usize) -> BIT {
                    BIT { tree: vec![0; n] }
                }
                pub fn add(&mut self, at: usize, by: i64) {
                    let mut idx = at;
                    while idx < self.tree.len() {
                        self.tree[idx] += by;
                        idx |= idx + 1;
                    }
                }
                pub fn get(&self, begin: usize, end: usize) -> i64 {
                    if begin >= end {
                        return 0;
                    }
                    let a = if end > 0 {
                        self.cum(end - 1)
                    } else {
                        0
                    };
                    let b = if begin > 0 {
                        self.cum(begin - 1)
                    } else {
                        0
                    };
                    a - b
                }
                fn cum(&self, last: usize) -> i64 {
                    let mut res = 0;
                    let mut idx = last as i64;
                    while idx >= 0 {
                        res += self.tree[idx as usize];
                        idx = (idx & (idx + 1)) - 1;
                    }
                    res
                }
            }
            impl BITRange {
                pub fn new(n: usize) -> BITRange {
                    BITRange {
                        bit0: BIT::new(n + 1),
                        bit1: BIT::new(n + 1),
                    }
                }
                pub fn add(&mut self, begin: usize, end: usize, by: i64) {
                    let a = begin as i64;
                    let b = end as i64;
                    self.bit0.add(begin, -by * a);
                    self.bit0.add(end, by * b);
                    self.bit1.add(begin, by);
                    self.bit1.add(end, -by);
                }
                pub fn get(&self, begin: usize, end: usize) -> i64 {
                    if begin >= end {
                        return 0;
                    }
                    self.cum(end) - self.cum(begin)
                }
                fn cum(&self, end: usize) -> i64 {
                    let a = self.bit0.get(0, end);
                    let b = self.bit1.get(0, end);
                    return a + b * end as i64;
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                #[test]
                fn test_simple() {
                    let mut bit = BIT::new(10);
                    bit.add(2, 1);
                    bit.add(3, 3);
                    bit.add(5, 10);
                    bit.add(0, -4);
                    bit.add(9, -5);
                    assert_eq!(5, bit.get(0, 10));
                    assert_eq!(4, bit.get(2, 4));
                    assert_eq!(1, bit.get(2, 3));
                    assert_eq!(0, bit.get(2, 2));
                    assert_eq!(0, bit.get(2, 0));
                    assert_eq!(-4, bit.get(0, 1));
                    assert_eq!(5, bit.get(5, 10));
                    let mut bit = BITRange::new(10);
                    bit.add(1, 3, 1);
                    bit.add(2, 5, 2);
                    assert_eq!(1, bit.get(1, 2));
                    assert_eq!(4, bit.get(1, 3));
                    assert_eq!(6, bit.get(1, 4));
                    assert_eq!(6, bit.get(0, 4));
                }
            }
        }
        pub mod union_find {
            pub struct UnionFind {
                data: Vec<i32>,
            }
            impl UnionFind {
                pub fn new(n: usize) -> UnionFind {
                    UnionFind { data: vec![-1; n] }
                }
                pub fn unite(&mut self, x: usize, y: usize) -> bool {
                    let x = self.root(x);
                    let y = self.root(y);
                    if x != y {
                        let (x, y) = if self.data[x] <= self.data[y] {
                            (x, y)
                        } else {
                            (y, x)
                        };
                        self.data[x] += self.data[y];
                        self.data[y] = x as i32;
                    }
                    x != y
                }
                pub fn same(&mut self, x: usize, y: usize) -> bool {
                    self.root(x) == self.root(y)
                }
                pub fn size(&mut self, x: usize) -> u32 {
                    let r = self.root(x);
                    (-self.data[r]) as u32
                }
                pub fn root(&mut self, x: usize) -> usize {
                    if self.data[x] < 0 {
                        x
                    } else {
                        let nx = self.data[x] as usize;
                        let r = self.root(nx);
                        self.data[x] = r as i32;
                        r
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                #[test]
                fn test_simple() {
                    let mut uf = UnionFind::new(3);
                    assert_eq!(1, uf.size(0));
                    assert_eq!(1, uf.size(1));
                    assert_eq!(1, uf.size(2));
                    assert_eq!(0, uf.root(0));
                    assert_eq!(1, uf.root(1));
                    assert_eq!(2, uf.root(2));
                    assert!(!uf.same(1, 2));
                    uf.unite(1, 2);
                    assert_ne!(uf.root(0), uf.root(2));
                    assert_eq!(uf.root(1), uf.root(2));
                    assert_eq!(1, uf.size(0));
                    assert_eq!(2, uf.size(1));
                    assert_eq!(2, uf.size(2));
                    assert!(uf.same(1, 2));
                    uf.unite(0, 1);
                    assert_eq!(uf.root(0), uf.root(2));
                    assert_eq!(uf.root(1), uf.root(2));
                    assert_eq!(3, uf.size(0));
                    assert_eq!(3, uf.size(1));
                    assert_eq!(3, uf.size(2));
                    assert!(uf.same(1, 2));
                    assert!(uf.same(0, 2));
                }
            }
        }
    }
    pub mod util {
        pub mod permutation {
            pub trait Permutation {
                fn next_permutation(&mut self) -> bool;
                fn prev_permutation(&mut self) -> bool;
            }
            impl<T> Permutation for [T]
            where
                T: Ord,
            {
                fn next_permutation(&mut self) -> bool {
                    if self.len() <= 1 {
                        return false;
                    }
                    let mut i = self.len() - 1;
                    while i > 0 && self[i - 1] >= self[i] {
                        i -= 1;
                    }
                    if i == 0 {
                        return false;
                    }
                    let mut j = self.len() - 1;
                    while self[j] <= self[i - 1] {
                        j -= 1;
                    }
                    self.swap(j, i - 1);
                    self[i..].reverse();
                    true
                }
                fn prev_permutation(&mut self) -> bool {
                    if self.len() <= 1 {
                        return false;
                    }
                    let mut i = self.len() - 1;
                    while i > 0 && self[i - 1] <= self[i] {
                        i -= 1;
                    }
                    if i == 0 {
                        return false;
                    }
                    self[i..].reverse();
                    let mut j = self.len() - 1;
                    while self[j - 1] < self[i - 1] {
                        j -= 1;
                    }
                    self.swap(i - 1, j);
                    true
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                #[test]
                fn test_simple() {
                    let mut data = [0, 0, 1, 1, 2];
                    data.next_permutation();
                    assert_eq!(&data, &[0, 0, 1, 2, 1]);
                    data.next_permutation();
                    assert_eq!(&data, &[0, 0, 2, 1, 1]);
                    data.next_permutation();
                    assert_eq!(&data, &[0, 1, 0, 1, 2]);
                    data.next_permutation();
                    assert_eq!(&data, &[0, 1, 0, 2, 1]);
                    data.next_permutation();
                    assert_eq!(&data, &[0, 1, 1, 0, 2]);
                    data.prev_permutation();
                    assert_eq!(&data, &[0, 1, 0, 2, 1]);
                    data.prev_permutation();
                    assert_eq!(&data, &[0, 1, 0, 1, 2]);
                    data.prev_permutation();
                    assert_eq!(&data, &[0, 0, 2, 1, 1]);
                    data.prev_permutation();
                    assert_eq!(&data, &[0, 0, 1, 2, 1]);
                    data.prev_permutation();
                    assert_eq!(&data, &[0, 0, 1, 1, 2]);
                    assert!(!data.prev_permutation());
                }
            }
        }
        pub mod rand {
            use std::{marker, mem};
            use std::io::{self, Read};
            use std::fs::File;
            use std::char;
            #[derive(Debug, Clone, Copy)]
            pub struct Xoroshiro128Rng {
                state: [u64; 2],
            }
            impl Xoroshiro128Rng {
                pub fn new_unseeded() -> Self {
                    Xoroshiro128Rng {
                        state: [1817879012901901417, 10917585336602961851],
                    }
                }
                pub fn from_seed(x: u64, y: u64) -> Self {
                    Xoroshiro128Rng { state: [x, y] }
                }
                pub fn new() -> Self {
                    let mut rng = OsRng::new().unwrap();
                    Self::from_seed(rng.gen(), rng.gen())
                }
            }
            impl Rng for Xoroshiro128Rng {
                fn next_u32(&mut self) -> u32 {
                    self.next_u64() as u32
                }
                fn next_u64(&mut self) -> u64 {
                    let s0: u64 = self.state[0];
                    let mut s1: u64 = self.state[1];
                    let result: u64 = s0.wrapping_add(s1);
                    s1 ^= s0;
                    self.state[0] = s0.rotate_left(55) ^ s1 ^ (s1 << 14);
                    self.state[1] = s1.rotate_left(36);
                    result
                }
            }
            pub trait Rand: Sized {
                fn rand<R: Rng>(rng: &mut R) -> Self;
            }
            pub trait Rng {
                fn next_u32(&mut self) -> u32;
                fn next_u64(&mut self) -> u64 {
                    let x = self.next_u32() as u64;
                    let y = self.next_u32() as u64;
                    (y << 32) | x
                }
                fn next_f32(&mut self) -> f32 {
                    const UPPER_MASK: u32 = 1065353216;
                    const LOWER_MASK: u32 = 8388607;
                    let tmp = UPPER_MASK | (self.next_u32() & LOWER_MASK);
                    let result: f32 = unsafe { mem::transmute(tmp) };
                    result - 1.0
                }
                fn next_f64(&mut self) -> f64 {
                    const UPPER_MASK: u64 = 4607182418800017408;
                    const LOWER_MASK: u64 = 4503599627370495;
                    let tmp = UPPER_MASK | (self.next_u64() & LOWER_MASK);
                    let result: f64 = unsafe { mem::transmute(tmp) };
                    result - 1.0
                }
                #[inline(always)]
                fn gen<T: Rand>(&mut self) -> T
                where
                    Self: Sized,
                {
                    Rand::rand(self)
                }
                fn gen_iter<'a, T: Rand>(&'a mut self) -> Generator<'a, T, Self>
                where
                    Self: Sized,
                {
                    Generator {
                        rng: self,
                        _marker: marker::PhantomData,
                    }
                }
                fn shuffle<T>(&mut self, values: &mut [T])
                where
                    Self: Sized,
                {
                    let mut i = values.len();
                    while i >= 2 {
                        i -= 1;
                        values.swap(i, (self.next_u64() as usize) % i);
                    }
                }
            }
            #[derive(Debug)]
            pub struct Generator<'a, T, R: 'a> {
                rng: &'a mut R,
                _marker: marker::PhantomData<fn() -> T>,
            }
            impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R> {
                type Item = T;
                fn next(&mut self) -> Option<T> {
                    Some(self.rng.gen())
                }
            }
            pub struct OsRng {
                reader: File,
            }
            impl OsRng {
                pub fn new() -> io::Result<OsRng> {
                    let reader = File::open("/dev/urandom")?;
                    Ok(OsRng { reader: reader })
                }
            }
            impl Rng for OsRng {
                fn next_u32(&mut self) -> u32 {
                    let mut dest = [0u8; 4];
                    self.reader.read_exact(&mut dest).unwrap();
                    unsafe { mem::transmute::<[u8; 4], u32>(dest) }
                }
            }
            impl Rand for isize {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> isize {
                    if mem::size_of::<isize>() == 4 {
                        rng.gen::<i32>() as isize
                    } else {
                        rng.gen::<i64>() as isize
                    }
                }
            }
            impl Rand for i8 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> i8 {
                    rng.next_u32() as i8
                }
            }
            impl Rand for i16 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> i16 {
                    rng.next_u32() as i16
                }
            }
            impl Rand for i32 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> i32 {
                    rng.next_u32() as i32
                }
            }
            impl Rand for i64 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> i64 {
                    rng.next_u64() as i64
                }
            }
            #[cfg(feature = "i128_support")]
            impl Rand for i128 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> i128 {
                    rng.gen::<u128>() as i128
                }
            }
            impl Rand for usize {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> usize {
                    if mem::size_of::<usize>() == 4 {
                        rng.gen::<u32>() as usize
                    } else {
                        rng.gen::<u64>() as usize
                    }
                }
            }
            impl Rand for u8 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> u8 {
                    rng.next_u32() as u8
                }
            }
            impl Rand for u16 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> u16 {
                    rng.next_u32() as u16
                }
            }
            impl Rand for u32 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> u32 {
                    rng.next_u32()
                }
            }
            impl Rand for u64 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> u64 {
                    rng.next_u64()
                }
            }
            #[cfg(feature = "i128_support")]
            impl Rand for u128 {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> u128 {
                    ((rng.next_u64() as u128) << 64) | (rng.next_u64() as u128)
                }
            }
            impl Rand for f64 {
                fn rand<R: Rng>(rng: &mut R) -> f64 {
                    rng.next_f64()
                }
            }
            impl Rand for f32 {
                fn rand<R: Rng>(rng: &mut R) -> f32 {
                    rng.next_f32()
                }
            }
            impl Rand for char {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> char {
                    const CHAR_MASK: u32 = 2097151;
                    loop {
                        match char::from_u32(rng.next_u32() & CHAR_MASK) {
                            Some(c) => return c,
                            None => {}
                        }
                    }
                }
            }
            impl Rand for bool {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> bool {
                    rng.gen::<u8>() & 1 == 1
                }
            }
            macro_rules! tuple_impl(( $ ( $ tyvar : ident ) , * ) => {
                                impl < $ ( $ tyvar : Rand ) , * > Rand for (
                                $ ( $ tyvar ) , * , ) {
                                # [ inline ] fn rand < R : Rng > (
                                _rng : & mut R ) -> ( $ ( $ tyvar ) , * , ) {
                                ( $ ( _rng . gen :: < $ tyvar > (  ) ) , * , )
                                } } });
            impl Rand for () {
                #[inline]
                fn rand<R: Rng>(_: &mut R) -> () {
                    ()
                }
            }
            tuple_impl!(A);
            tuple_impl!(A, B);
            tuple_impl!(A, B, C);
            tuple_impl!(A, B, C, D);
            tuple_impl!(A, B, C, D, E);
            tuple_impl!(A, B, C, D, E, F);
            tuple_impl!(A, B, C, D, E, F, G);
            tuple_impl!(A, B, C, D, E, F, G, H);
            tuple_impl!(A, B, C, D, E, F, G, H, I);
            tuple_impl!(A, B, C, D, E, F, G, H, I, J);
            tuple_impl!(A, B, C, D, E, F, G, H, I, J, K);
            tuple_impl!(A, B, C, D, E, F, G, H, I, J, K, L);
            macro_rules! array_impl({
                                $ n : expr , $ t : ident , $ ( $ ts : ident ,
                                ) * } => {
                                array_impl ! { ( $ n - 1 ) , $ ( $ ts , ) * }
                                impl < T > Rand for [ T ; $ n ] where T : Rand
                                {
                                # [ inline ] fn rand < R : Rng > (
                                _rng : & mut R ) -> [ T ; $ n ] {
                                [
                                _rng . gen :: < $ t > (  ) , $ (
                                _rng . gen :: < $ ts > (  ) ) , * ] } } } ; {
                                $ n : expr , } => {
                                impl < T > Rand for [ T ; $ n ] {
                                fn rand < R : Rng > ( _rng : & mut R ) -> [
                                T ; $ n ] { [  ] } } } ;);
            array_impl!(
                32,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
                T,
            );
            impl<T: Rand> Rand for Option<T> {
                #[inline]
                fn rand<R: Rng>(rng: &mut R) -> Option<T> {
                    if rng.gen() {
                        Some(rng.gen())
                    } else {
                        None
                    }
                }
            }
        }
    }
}