QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#457532#8836. Highway Hoaxucup-team635#AC ✓274ms52016kbRust26.2kb2024-06-29 13:11:552024-06-29 13:14:13

Judging History

你现在查看的是最新测评结果

  • [2024-06-29 13:14:13]
  • 评测
  • 测评结果:AC
  • 用时:274ms
  • 内存:52016kb
  • [2024-06-29 13:11:55]
  • 提交

answer

use std::collections::*;
use std::io::Write;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    input! {
        n: usize,
        s: bytes,
        e: [(usize1, usize1); n - 1],
    }
    type M = ModInt<998244353>;
    for root in 0..1 {
        let mut g = vec![vec![]; n];
        for &(a, b) in e.iter() {
            g[a].push((b, 0));
            g[b].push((a, 1));
        }
        let mut topo = vec![root];
        for i in 0..n {
            let v = topo[i];
            for (u, _) in g[v].clone() {
                g[u].retain(|p| p.0 != v);
                topo.push(u);
            }
        }
        // 0: 無
        // 1: Sを親に渡す
        // 2: Sを親からもらう
        let mut dp = vec![(M::zero(), M::zero(), M::zero()); n];
        for &v in topo.iter().rev() {
            // 1: そのまま
            // 2: Sを渡す
            // 0: Sをもらう
            let mut deq = Deque::new();
            deq.push_back(vec![M::one()]);
            for &(u, k) in g[v].iter() {
                let mut f = vec![M::zero(); 3];
                let p = dp[u];
                f[1] += p.0;
                if k == 0 {
                    f[2] += p.2;
                } else {
                    f[0] += p.1;
                }
                deq.push_back(f);
            }
            while deq.len() > 1 {
                let a = deq.pop_front().unwrap();
                let b = deq.pop_front().unwrap();
                deq.push_back(a.convolution(&b));
            }
            let mid = g[v].len();
            let f = deq.pop_front().unwrap();
            dp[v].0 += f[mid];
            if s[v] == b'S' {
                dp[v].1 += f[mid];
                if mid > 0 {
                    dp[v].1 += f[mid - 1];
                    dp[v].0 += f[mid + 1];
                    dp[v].2 += f[mid + 1];
                }
                if mid > 1 {
                    dp[v].2 += f[mid + 2];
                }
            } else {
                dp[v].2 += f[mid];
                if mid > 0 {
                    dp[v].2 += f[mid + 1];
                    dp[v].0 += f[mid - 1];
                    dp[v].1 += f[mid - 1];
                }
                if mid > 1 {
                    dp[v].1 += f[mid - 2];
                }
            }
        }
        println!("{}", dp[root].0);
    }
}

// ---------- begin input macro ----------
// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
#[macro_export]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

#[macro_export]
macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

#[macro_export]
macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, bytes) => {
        read_value!($iter, String).bytes().collect::<Vec<u8>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
// ---------- end input macro ----------

use std::ops::*;

// ---------- begin trait ----------
pub trait Zero: Sized + Add<Self, Output = Self> {
    fn zero() -> Self;
    fn is_zero(&self) -> bool;
}

pub trait One: Sized + Mul<Self, Output = Self> {
    fn one() -> Self;
    fn is_one(&self) -> bool;
}

pub trait SemiRing: Zero + One {}

pub trait Ring: SemiRing + Sub<Output = Self> + Neg<Output = Self> {}

pub trait Field: Ring + Div<Output = Self> {}

impl<T> SemiRing for T where T: Zero + One {}

impl<T> Ring for T where T: SemiRing + Sub<Output = Self> + Neg<Output = Self> {}

impl<T> Field for T where T: Ring + Div<Output = Self> {}
// ---------- end trait ----------
// ---------- begin modint ----------
pub const fn pow_mod(mut r: u32, mut n: u32, m: u32) -> u32 {
    let mut t = 1;
    while n > 0 {
        if n & 1 == 1 {
            t = (t as u64 * r as u64 % m as u64) as u32;
        }
        r = (r as u64 * r as u64 % m as u64) as u32;
        n >>= 1;
    }
    t
}

pub const fn primitive_root(p: u32) -> u32 {
    let mut m = p - 1;
    let mut f = [1; 30];
    let mut k = 0;
    let mut d = 2;
    while d * d <= m {
        if m % d == 0 {
            f[k] = d;
            k += 1;
        }
        while m % d == 0 {
            m /= d;
        }
        d += 1;
    }
    if m > 1 {
        f[k] = m;
        k += 1;
    }
    let mut g = 1;
    while g < p {
        let mut ok = true;
        let mut i = 0;
        while i < k {
            ok &= pow_mod(g, (p - 1) / f[i], p) > 1;
            i += 1;
        }
        if ok {
            break;
        }
        g += 1;
    }
    g
}

pub const fn is_prime(n: u32) -> bool {
    if n <= 1 {
        return false;
    }
    let mut d = 2;
    while d * d <= n {
        if n % d == 0 {
            return false;
        }
        d += 1;
    }
    true
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub struct ModInt<const M: u32>(u32);

impl<const M: u32> ModInt<{ M }> {
    const REM: u32 = {
        let mut t = 1u32;
        let mut s = !M + 1;
        let mut n = !0u32 >> 2;
        while n > 0 {
            if n & 1 == 1 {
                t = t.wrapping_mul(s);
            }
            s = s.wrapping_mul(s);
            n >>= 1;
        }
        t
    };
    const INI: u64 = ((1u128 << 64) % M as u128) as u64;
    const IS_PRIME: () = assert!(is_prime(M));
    const PRIMITIVE_ROOT: u32 = primitive_root(M);
    const ORDER: usize = 1 << (M - 1).trailing_zeros();
    const fn reduce(x: u64) -> u32 {
        let _ = Self::IS_PRIME;
        let b = (x as u32 * Self::REM) as u64;
        let t = x + b * M as u64;
        let mut c = (t >> 32) as u32;
        if c >= M {
            c -= M;
        }
        c as u32
    }
    const fn multiply(a: u32, b: u32) -> u32 {
        Self::reduce(a as u64 * b as u64)
    }
    pub const fn new(v: u32) -> Self {
        assert!(v < M);
        Self(Self::reduce(v as u64 * Self::INI))
    }
    pub const fn const_mul(&self, rhs: Self) -> Self {
        Self(Self::multiply(self.0, rhs.0))
    }
    pub const fn pow(&self, mut n: u64) -> Self {
        let mut t = Self::new(1);
        let mut r = *self;
        while n > 0 {
            if n & 1 == 1 {
                t = t.const_mul(r);
            }
            r = r.const_mul(r);
            n >>= 1;
        }
        t
    }
    pub const fn inv(&self) -> Self {
        assert!(self.0 != 0);
        self.pow(M as u64 - 2)
    }
    pub const fn get(&self) -> u32 {
        Self::reduce(self.0 as u64)
    }
    pub const fn zero() -> Self {
        Self::new(0)
    }
    pub const fn one() -> Self {
        Self::new(1)
    }
}

impl<const M: u32> Add for ModInt<{ M }> {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        let mut v = self.0 + rhs.0;
        if v >= M {
            v -= M;
        }
        Self(v)
    }
}

impl<const M: u32> Sub for ModInt<{ M }> {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        let mut v = self.0 - rhs.0;
        if self.0 < rhs.0 {
            v += M;
        }
        Self(v)
    }
}

impl<const M: u32> Mul for ModInt<{ M }> {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {
        self.const_mul(rhs)
    }
}

impl<const M: u32> Div for ModInt<{ M }> {
    type Output = Self;
    fn div(self, rhs: Self) -> Self::Output {
        self * rhs.inv()
    }
}

impl<const M: u32> AddAssign for ModInt<{ M }> {
    fn add_assign(&mut self, rhs: Self) {
        *self = *self + rhs;
    }
}

impl<const M: u32> SubAssign for ModInt<{ M }> {
    fn sub_assign(&mut self, rhs: Self) {
        *self = *self - rhs;
    }
}

impl<const M: u32> MulAssign for ModInt<{ M }> {
    fn mul_assign(&mut self, rhs: Self) {
        *self = *self * rhs;
    }
}

impl<const M: u32> DivAssign for ModInt<{ M }> {
    fn div_assign(&mut self, rhs: Self) {
        *self = *self / rhs;
    }
}

impl<const M: u32> Neg for ModInt<{ M }> {
    type Output = Self;
    fn neg(self) -> Self::Output {
        if self.0 == 0 {
            self
        } else {
            Self(M - self.0)
        }
    }
}

impl<const M: u32> std::fmt::Display for ModInt<{ M }> {
    fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {
        write!(f, "{}", self.get())
    }
}

impl<const M: u32> std::fmt::Debug for ModInt<{ M }> {
    fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {
        write!(f, "{}", self.get())
    }
}

impl<const M: u32> std::str::FromStr for ModInt<{ M }> {
    type Err = std::num::ParseIntError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let val = s.parse::<u32>()?;
        Ok(ModInt::new(val))
    }
}

impl<const M: u32> From<usize> for ModInt<{ M }> {
    fn from(val: usize) -> ModInt<{ M }> {
        ModInt::new((val % M as usize) as u32)
    }
}
// ---------- end modint ----------
// ---------- begin precalc ----------
pub struct Precalc<const MOD: u32> {
    fact: Vec<ModInt<MOD>>,
    ifact: Vec<ModInt<MOD>>,
    inv: Vec<ModInt<MOD>>,
}

impl<const MOD: u32> Precalc<MOD> {
    pub fn new(size: usize) -> Self {
        let mut fact = vec![ModInt::one(); size + 1];
        let mut ifact = vec![ModInt::one(); size + 1];
        let mut inv = vec![ModInt::one(); size + 1];
        for i in 2..=size {
            fact[i] = fact[i - 1] * ModInt::from(i);
        }
        ifact[size] = fact[size].inv();
        for i in (2..=size).rev() {
            inv[i] = ifact[i] * fact[i - 1];
            ifact[i - 1] = ifact[i] * ModInt::from(i);
        }
        Self { fact, ifact, inv }
    }
    pub fn fact(&self, n: usize) -> ModInt<MOD> {
        self.fact[n]
    }
    pub fn ifact(&self, n: usize) -> ModInt<MOD> {
        self.ifact[n]
    }
    pub fn inv(&self, n: usize) -> ModInt<MOD> {
        assert!(0 < n);
        self.inv[n]
    }
    pub fn perm(&self, n: usize, k: usize) -> ModInt<MOD> {
        if k > n {
            return ModInt::zero();
        }
        self.fact[n] * self.ifact[n - k]
    }
    pub fn binom(&self, n: usize, k: usize) -> ModInt<MOD> {
        if n < k {
            return ModInt::zero();
        }
        self.fact[n] * self.ifact[k] * self.ifact[n - k]
    }
}
// ---------- end precalc ----------

impl<const M: u32> Zero for ModInt<{ M }> {
    fn zero() -> Self {
        Self::zero()
    }
    fn is_zero(&self) -> bool {
        self.0 == 0
    }
}

impl<const M: u32> One for ModInt<{ M }> {
    fn one() -> Self {
        Self::one()
    }
    fn is_one(&self) -> bool {
        self.get() == 1
    }
}

// ---------- begin array op ----------

struct NTTPrecalc<const M: u32> {
    sum_e: [ModInt<{ M }>; 30],
    sum_ie: [ModInt<{ M }>; 30],
}

impl<const M: u32> NTTPrecalc<{ M }> {
    const fn new() -> Self {
        let cnt2 = (M - 1).trailing_zeros() as usize;
        let root = ModInt::new(ModInt::<{ M }>::PRIMITIVE_ROOT);
        let zeta = root.pow((M - 1) as u64 >> cnt2);
        let mut es = [ModInt::zero(); 30];
        let mut ies = [ModInt::zero(); 30];
        let mut sum_e = [ModInt::zero(); 30];
        let mut sum_ie = [ModInt::zero(); 30];
        let mut e = zeta;
        let mut ie = e.inv();
        let mut i = cnt2;
        while i >= 2 {
            es[i - 2] = e;
            ies[i - 2] = ie;
            e = e.const_mul(e);
            ie = ie.const_mul(ie);
            i -= 1;
        }
        let mut now = ModInt::one();
        let mut inow = ModInt::one();
        let mut i = 0;
        while i < cnt2 - 1 {
            sum_e[i] = es[i].const_mul(now);
            sum_ie[i] = ies[i].const_mul(inow);
            now = ies[i].const_mul(now);
            inow = es[i].const_mul(inow);
            i += 1;
        }
        Self { sum_e, sum_ie }
    }
}

struct NTTPrecalcHelper<const MOD: u32>;
impl<const MOD: u32> NTTPrecalcHelper<MOD> {
    const A: NTTPrecalc<MOD> = NTTPrecalc::new();
}

pub trait ArrayAdd {
    type Item;
    fn add(&self, rhs: &[Self::Item]) -> Vec<Self::Item>;
}

impl<T> ArrayAdd for [T]
where
    T: Zero + Copy,
{
    type Item = T;
    fn add(&self, rhs: &[Self::Item]) -> Vec<Self::Item> {
        let mut c = vec![T::zero(); self.len().max(rhs.len())];
        c[..self.len()].copy_from_slice(self);
        c.add_assign(rhs);
        c
    }
}

pub trait ArrayAddAssign {
    type Item;
    fn add_assign(&mut self, rhs: &[Self::Item]);
}

impl<T> ArrayAddAssign for [T]
where
    T: Add<Output = T> + Copy,
{
    type Item = T;
    fn add_assign(&mut self, rhs: &[Self::Item]) {
        assert!(self.len() >= rhs.len());
        self.iter_mut().zip(rhs).for_each(|(x, a)| *x = *x + *a);
    }
}

impl<T> ArrayAddAssign for Vec<T>
where
    T: Zero + Add<Output = T> + Copy,
{
    type Item = T;
    fn add_assign(&mut self, rhs: &[Self::Item]) {
        if self.len() < rhs.len() {
            self.resize(rhs.len(), T::zero());
        }
        self.as_mut_slice().add_assign(rhs);
    }
}

pub trait ArraySub {
    type Item;
    fn sub(&self, rhs: &[Self::Item]) -> Vec<Self::Item>;
}

impl<T> ArraySub for [T]
where
    T: Zero + Sub<Output = T> + Copy,
{
    type Item = T;
    fn sub(&self, rhs: &[Self::Item]) -> Vec<Self::Item> {
        let mut c = vec![T::zero(); self.len().max(rhs.len())];
        c[..self.len()].copy_from_slice(self);
        c.sub_assign(rhs);
        c
    }
}

pub trait ArraySubAssign {
    type Item;
    fn sub_assign(&mut self, rhs: &[Self::Item]);
}

impl<T> ArraySubAssign for [T]
where
    T: Sub<Output = T> + Copy,
{
    type Item = T;
    fn sub_assign(&mut self, rhs: &[Self::Item]) {
        assert!(self.len() >= rhs.len());
        self.iter_mut().zip(rhs).for_each(|(x, a)| *x = *x - *a);
    }
}

impl<T> ArraySubAssign for Vec<T>
where
    T: Zero + Sub<Output = T> + Copy,
{
    type Item = T;
    fn sub_assign(&mut self, rhs: &[Self::Item]) {
        if self.len() < rhs.len() {
            self.resize(rhs.len(), T::zero());
        }
        self.as_mut_slice().sub_assign(rhs);
    }
}

pub trait ArrayDot {
    type Item;
    fn dot(&self, rhs: &[Self::Item]) -> Vec<Self::Item>;
}

impl<T> ArrayDot for [T]
where
    T: Mul<Output = T> + Copy,
{
    type Item = T;
    fn dot(&self, rhs: &[Self::Item]) -> Vec<Self::Item> {
        assert!(self.len() == rhs.len());
        self.iter().zip(rhs).map(|p| *p.0 * *p.1).collect()
    }
}

pub trait ArrayDotAssign {
    type Item;
    fn dot_assign(&mut self, rhs: &[Self::Item]);
}

impl<T> ArrayDotAssign for [T]
where
    T: MulAssign + Copy,
{
    type Item = T;
    fn dot_assign(&mut self, rhs: &[Self::Item]) {
        assert!(self.len() == rhs.len());
        self.iter_mut().zip(rhs).for_each(|(x, a)| *x *= *a);
    }
}

pub trait ArrayMul {
    type Item;
    fn mul(&self, rhs: &[Self::Item]) -> Vec<Self::Item>;
}

impl<T> ArrayMul for [T]
where
    T: Zero + One + Copy,
{
    type Item = T;
    fn mul(&self, rhs: &[Self::Item]) -> Vec<Self::Item> {
        if self.is_empty() || rhs.is_empty() {
            return vec![];
        }
        let mut res = vec![T::zero(); self.len() + rhs.len() - 1];
        for (i, a) in self.iter().enumerate() {
            for (res, b) in res[i..].iter_mut().zip(rhs.iter()) {
                *res = *res + *a * *b;
            }
        }
        res
    }
}

// transform でlen=1を指定すればNTTになる
pub trait ArrayConvolution {
    type Item;
    fn transform(&mut self, len: usize);
    fn inverse_transform(&mut self, len: usize);
    fn convolution(&self, rhs: &[Self::Item]) -> Vec<Self::Item>;
}

impl<const M: u32> ArrayConvolution for [ModInt<{ M }>] {
    type Item = ModInt<{ M }>;
    fn transform(&mut self, len: usize) {
        let f = self;
        let n = f.len();
        let k = (n / len).trailing_zeros() as usize;
        assert!(len << k == n);
        assert!(k <= ModInt::<{ M }>::ORDER);
        let pre = &NTTPrecalcHelper::<{ M }>::A;
        for ph in 1..=k {
            let p = len << (k - ph);
            let mut now = ModInt::one();
            for (i, f) in f.chunks_exact_mut(2 * p).enumerate() {
                let (x, y) = f.split_at_mut(p);
                for (x, y) in x.iter_mut().zip(y.iter_mut()) {
                    let l = *x;
                    let r = *y * now;
                    *x = l + r;
                    *y = l - r;
                }
                now *= pre.sum_e[(!i).trailing_zeros() as usize];
            }
        }
    }
    fn inverse_transform(&mut self, len: usize) {
        let f = self;
        let n = f.len();
        let k = (n / len).trailing_zeros() as usize;
        assert!(len << k == n);
        assert!(k <= ModInt::<{ M }>::ORDER);
        let pre = &NTTPrecalcHelper::<{ M }>::A;
        for ph in (1..=k).rev() {
            let p = len << (k - ph);
            let mut inow = ModInt::one();
            for (i, f) in f.chunks_exact_mut(2 * p).enumerate() {
                let (x, y) = f.split_at_mut(p);
                for (x, y) in x.iter_mut().zip(y.iter_mut()) {
                    let l = *x;
                    let r = *y;
                    *x = l + r;
                    *y = (l - r) * inow;
                }
                inow *= pre.sum_ie[(!i).trailing_zeros() as usize];
            }
        }
        let ik = ModInt::new(2).inv().pow(k as u64);
        for f in f.iter_mut() {
            *f *= ik;
        }
    }
    fn convolution(&self, rhs: &[Self::Item]) -> Vec<Self::Item> {
        if self.len().min(rhs.len()) <= 32 {
            return self.mul(rhs);
        }
        const PARAM: usize = 10;
        let size = self.len() + rhs.len() - 1;
        let mut k = 0;
        while (size + (1 << k) - 1) >> k > PARAM {
            k += 1;
        }
        let len = (size + (1 << k) - 1) >> k;
        let mut f = vec![ModInt::zero(); len << k];
        let mut g = vec![ModInt::zero(); len << k];
        f[..self.len()].copy_from_slice(self);
        g[..rhs.len()].copy_from_slice(rhs);
        f.transform(len);
        g.transform(len);
        let mut buf = [ModInt::zero(); 2 * PARAM - 1];
        let buf = &mut buf[..(2 * len - 1)];
        let pre = &NTTPrecalcHelper::<{ M }>::A;
        let mut now = ModInt::one();
        for (i, (f, g)) in f
            .chunks_exact_mut(2 * len)
            .zip(g.chunks_exact(2 * len))
            .enumerate()
        {
            let mut r = now;
            for (f, g) in f.chunks_exact_mut(len).zip(g.chunks_exact(len)) {
                buf.fill(ModInt::zero());
                for (i, f) in f.iter().enumerate() {
                    for (buf, g) in buf[i..].iter_mut().zip(g.iter()) {
                        *buf = *buf + *f * *g;
                    }
                }
                f.copy_from_slice(&buf[..len]);
                for (f, buf) in f.iter_mut().zip(buf[len..].iter()) {
                    *f = *f + r * *buf;
                }
                r = -r;
            }
            now *= pre.sum_e[(!i).trailing_zeros() as usize];
        }
        f.inverse_transform(len);
        f.truncate(self.len() + rhs.len() - 1);
        f
    }
}
// ---------- end array op ----------
// ---------- begin const matrix ----------
#[derive(Clone, Debug)]
pub struct Matrix<T, const R: usize, const C: usize>([[T; C]; R]);

impl<T, const R: usize, const C: usize> Matrix<T, R, C> {
    pub fn new(a: [[T; C]; R]) -> Self {
        Self(a)
    }
    pub fn iter(&self) -> impl Iterator<Item = &[T; C]> {
        self.0.iter()
    }
    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut [T; C]> {
        self.0.iter_mut()
    }
    pub fn swap_row(&mut self, x: usize, y: usize) {
        assert!(x < R && y < R);
        self.0.swap(x, y);
    }
    pub fn swap_col(&mut self, x: usize, y: usize) {
        assert!(x < C && y < C);
        for mat in self.iter_mut() {
            mat.swap(x, y);
        }
    }
}

impl<T, const R: usize, const C: usize> Zero for Matrix<T, R, C>
where
    T: Zero + Copy,
{
    fn zero() -> Self {
        Self::new([[T::zero(); C]; R])
    }
    fn is_zero(&self) -> bool {
        self.iter().flatten().all(|a| a.is_zero())
    }
}

impl<T, const R: usize, const C: usize> Matrix<T, R, C>
where
    T: Add<Output = T> + Copy,
{
    pub fn matadd(&self, rhs: &Self) -> Self {
        let mut res = self.clone();
        for (res, rhs) in res.iter_mut().zip(rhs.iter()) {
            for (res, rhs) in res.iter_mut().zip(rhs.iter()) {
                *res = *res + *rhs;
            }
        }
        res
    }
}

impl<T, const R: usize, const C: usize> Add for Matrix<T, R, C>
where
    T: Add<Output = T> + Copy,
{
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        self.matadd(&rhs)
    }
}

impl<T, const R: usize, const C: usize> Matrix<T, R, C>
where
    T: Sub<Output = T> + Copy,
{
    pub fn matsub(&self, rhs: &Self) -> Self {
        let mut res = self.clone();
        for (res, rhs) in res.iter_mut().zip(rhs.iter()) {
            for (res, rhs) in res.iter_mut().zip(rhs.iter()) {
                *res = *res - *rhs;
            }
        }
        res
    }
}

impl<T, const R: usize, const C: usize> Sub for Matrix<T, R, C>
where
    T: Sub<Output = T> + Copy,
{
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        self.matsub(&rhs)
    }
}

impl<T, const N: usize> One for Matrix<T, N, N>
where
    T: Zero + One + Copy,
{
    fn one() -> Self {
        let mut res = Self::zero();
        for (i, a) in res.iter_mut().enumerate() {
            a[i] = T::one();
        }
        res
    }
    fn is_one(&self) -> bool {
        self.iter().enumerate().all(|(i, a)| {
            a.iter()
                .enumerate()
                .all(|(j, a)| (i == j && a.is_one()) || (i != j && a.is_zero()))
        })
    }
}

impl<T, const R: usize, const C: usize> Matrix<T, R, C>
where
    T: Zero + Mul<Output = T> + Copy,
{
    pub fn matmul<const M: usize>(&self, rhs: &Matrix<T, C, M>) -> Matrix<T, R, M> {
        let mut res = Matrix::<T, R, M>::zero();
        for (res, a) in res.iter_mut().zip(self.iter()) {
            for (a, b) in a.iter().zip(rhs.iter()) {
                for (res, b) in res.iter_mut().zip(b.iter()) {
                    *res = *res + *a * *b;
                }
            }
        }
        res
    }
}

impl<T, const R: usize, const C: usize, const M: usize> Mul<Matrix<T, C, M>> for Matrix<T, R, C>
where
    T: Zero + Mul<Output = T> + Copy,
{
    type Output = Matrix<T, R, M>;
    fn mul(self, rhs: Matrix<T, C, M>) -> Self::Output {
        self.matmul(&rhs)
    }
}

impl<T, const R: usize, const C: usize> Index<usize> for Matrix<T, R, C> {
    type Output = [T; C];
    fn index(&self, x: usize) -> &Self::Output {
        &self.0[x]
    }
}

impl<T, const R: usize, const C: usize> IndexMut<usize> for Matrix<T, R, C> {
    fn index_mut(&mut self, x: usize) -> &mut Self::Output {
        &mut self.0[x]
    }
}
// ---------- end const matrix ----------
fn rand_memory() -> usize {
    Box::into_raw(Box::new("I hope this is a random number")) as usize
}

fn rand() -> usize {
    static mut X: usize = 0;
    unsafe {
        if X == 0 {
            X = rand_memory();
        }
        X ^= X << 13;
        X ^= X >> 17;
        X ^= X << 5;
        X
    }
}

fn shuffle<T>(a: &mut [T]) {
    for i in 1..a.len() {
        let p = rand() % (i + 1);
        a.swap(i, p);
    }
}
//---------- begin union_find ----------
pub struct DSU {
    p: Vec<i32>,
}
impl DSU {
    pub fn new(n: usize) -> DSU {
        assert!(n < std::i32::MAX as usize);
        DSU { p: vec![-1; n] }
    }
    pub fn init(&mut self) {
        self.p.iter_mut().for_each(|p| *p = -1);
    }
    pub fn root(&self, mut x: usize) -> usize {
        assert!(x < self.p.len());
        while self.p[x] >= 0 {
            x = self.p[x] as usize;
        }
        x
    }
    pub fn same(&self, x: usize, y: usize) -> bool {
        assert!(x < self.p.len() && y < self.p.len());
        self.root(x) == self.root(y)
    }
    pub fn unite(&mut self, x: usize, y: usize) -> Option<(usize, usize)> {
        assert!(x < self.p.len() && y < self.p.len());
        let mut x = self.root(x);
        let mut y = self.root(y);
        if x == y {
            return None;
        }
        if self.p[x] > self.p[y] {
            std::mem::swap(&mut x, &mut y);
        }
        self.p[x] += self.p[y];
        self.p[y] = x as i32;
        Some((x, y))
    }
    pub fn parent(&self, x: usize) -> Option<usize> {
        assert!(x < self.p.len());
        let p = self.p[x];
        if p >= 0 {
            Some(p as usize)
        } else {
            None
        }
    }
    pub fn sum<F>(&self, mut x: usize, mut f: F) -> usize
    where
        F: FnMut(usize),
    {
        while let Some(p) = self.parent(x) {
            f(x);
            x = p;
        }
        x
    }
    pub fn size(&self, x: usize) -> usize {
        assert!(x < self.p.len());
        let r = self.root(x);
        (-self.p[r]) as usize
    }
}
//---------- end union_find ----------

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 0ms
memory: 2236kb

input:

5
SFSFS
2 1
2 3
4 3
4 5

output:

1

result:

ok 1 number(s): "1"

Test #2:

score: 0
Accepted
time: 0ms
memory: 2072kb

input:

4
SFFF
1 2
1 3
1 4

output:

4

result:

ok 1 number(s): "4"

Test #3:

score: 0
Accepted
time: 0ms
memory: 2052kb

input:

7
SSSSFFF
1 2
3 2
4 3
4 5
4 6
2 7

output:

13

result:

ok 1 number(s): "13"

Test #4:

score: 0
Accepted
time: 0ms
memory: 2028kb

input:

2
FS
1 2

output:

1

result:

ok 1 number(s): "1"

Test #5:

score: 0
Accepted
time: 0ms
memory: 2000kb

input:

3
FFF
3 1
3 2

output:

1

result:

ok 1 number(s): "1"

Test #6:

score: 0
Accepted
time: 0ms
memory: 2036kb

input:

4
FFFF
1 2
4 2
2 3

output:

1

result:

ok 1 number(s): "1"

Test #7:

score: 0
Accepted
time: 0ms
memory: 2068kb

input:

5
FFFFF
4 2
2 1
3 1
3 5

output:

1

result:

ok 1 number(s): "1"

Test #8:

score: 0
Accepted
time: 0ms
memory: 2128kb

input:

6
FSSSSF
5 3
2 5
1 2
2 6
4 2

output:

3

result:

ok 1 number(s): "3"

Test #9:

score: 0
Accepted
time: 271ms
memory: 52016kb

input:

199995
FSSFFFSSSFSFFSSSFSSSSSFSFSSSFSFFSSFSFSFFFSSSFSSFSFFSFFFFSSFFSSSFFSFSFFFFFFFFFFFFFSSSFSSFFFSSSFSFSSSFFFSFFSFSSSSFSFSFSFSSFFSFSFFSFFSSFSSSFSFFSSSFFSFFFSFFSFSFSFSFSSSFSSSSFFSSFFFFFSFSSSFFSSSSSSSSFFFSFSFFSSSFSFFFFFSFFFFSSSSSSSFFFSFFSFSSSFSFSFFFFSFSSFSSFFFSSFFFSSFSFFFSSSFSFSSFFSFSFFSFFSSFSFSSSSFFF...

output:

233157276

result:

ok 1 number(s): "233157276"

Test #10:

score: 0
Accepted
time: 258ms
memory: 51592kb

input:

199996
FSSFFSFSSSFFFFFFSFSSFSFFSSFFFFFFFSSSFFSFSSFSSFSFSSFSSSFFFFSFFFFFFSSSSFFFSFSSFSSFFSSFSFFSSSSSFSFFFFSFSFFSFSSFSFSSSSSFSFSSSFFSSFSSFSFFSFFSSFSFSSFSSSFSSSFFSSFFFFSFFSFSFSFFFSFSSSFFSFFSSSSSSSSFSSFSSFSSSSFSSSFSSSFSFFFFFFSFFSSSFSSFFFSFSFSFSSSFSFFSSSSFSSFSFSSFSSFSFFFSSSFFSSFSFSFFSSSFFFFSSSSSSSFSSSFFF...

output:

509139031

result:

ok 1 number(s): "509139031"

Test #11:

score: 0
Accepted
time: 256ms
memory: 51568kb

input:

199997
FFSSSFSSFSFSFSSSSFSFFSSFFFSSFFSSSSSSFSSSFFSSSFFFSFFSFSFSSSFFSSSFSFFFFFSSFFSSFFFFSSSFFFFSSSSFFFSSFFSSSFSFFSFSFSFSFFSSFSFSSSFSSFSSFSFFSSFFFSFSSFSFFSSSFSFFSFFFFSSFFSFSFFFSFSFFSFSFSFFSSFFFSSFSFFSFSSSSSFFFFFSSSSSSSSSFFFFSSFFFSSFFSFSFSSSFSFSFFSSSSFSFSFFFSSFSSFFSFFSSFSSSSSSSFSSSFSSSFSFSSSSFSFFSSSFSS...

output:

917209642

result:

ok 1 number(s): "917209642"

Test #12:

score: 0
Accepted
time: 274ms
memory: 51708kb

input:

199998
FFFSSSSSFSSSFFFFFFSSSSFSSFFFSFSSFFFSFFFFSFFFFFFFSSSFFSFSFFSFSFSFFSSFSFFSFSFSFSFFSSFFSFFFSFSFSSSSFSSSFFFSSSSFFSFFFFSFFFFFFSFSSFSFSSFFSSFSFFSFSSFSFSSFSSSSFSSFFSSFSSSSSSSSFFSFFSSSSSSSSSSSSFFSSFFFFFFSSFFSFFFFSSFFFSFFSSFFFFFFFFSFSSFSSSSFFSFSFFSSSSFSFSFFFSSFSFFFSFFSSFFSSSSSSSFSSSFFFSSFSSSSSFFFFSFSF...

output:

722227522

result:

ok 1 number(s): "722227522"

Test #13:

score: 0
Accepted
time: 264ms
memory: 51796kb

input:

199999
FSFSFSFSSFSSSFSSFFSFSFFFFFFSSFSSSFSFSSFFSSSFSSSFSSSFSFFSFSFFFFFFSFFFSFSSSSSSFFSFFSFFFFFFFSSSFFFSFFSSSFSFSSSSSFSSFSFSFFSFSFFSSFSFSSFFSFSSSSSSSSSSSFFSSSSSFSFFFSFFSFFFSFFFFFSFFFFSSSSSSSFFFFSFFSSSFSFSSFFFFSSFSFSFSSSFSSSSFSSFSFFSFFFSSFSSFFFSFSFFFSFFFFSFSFSSSSSSSFFSSFFFSSFSSSSSFSSSFFFFFSFSSSFFFSFFS...

output:

22915769

result:

ok 1 number(s): "22915769"

Test #14:

score: 0
Accepted
time: 249ms
memory: 51572kb

input:

200000
SFSSSSFSFFSFFFSFSFSSSSSSSSFFSSSFFSFFSSFFFFFFFFFFSSFFFFFFFSFFSFFFFFSSSFFFSFFSFFFFFSSFFSFFFFSSSFSFFSFSSFSFFFFFFFSFFSSFSSFSSFFSSFSSSSSFSSSSFFSFFFFFSSFSFFSFFFSSSSFFSFFFFFSSSSSSFFFSFFSFFFSFFFFFFSSSFSFFFFFSFSSSFFSSSFSFSFSSSFFFFFSSFFFSFSFFFSFSSSSSFSFFSFSSFFSSFSFFFFFSSFSFSFFFSSSFSFFFFSSSSFFFSSFFSFSFS...

output:

246807982

result:

ok 1 number(s): "246807982"

Test #15:

score: 0
Accepted
time: 252ms
memory: 42600kb

input:

199980
SFSFFSSSSSFSSSFFFSSSSFFSSFSSSSFFFFSSFFSSFFFFSFSSFFSSSSSFFFSSSSFFFFFFFSFFSFSSSFSFFFFSFSFFSFSFFSFSFSFSFFSSSSFFSSFSSFFFFSFSFFFFFSSSFSFFFFFFSFFSSSFFSSSFFSSSFSFSFSSSFSSSFSSSSSFSFFFSSSFSSSFFSFSFSFFFSSSSFSSSFSSFSSSFFFFFSFFSFFFFSSSFFSSFFSSSFSSSFSSSFSSFSFSSFSFSFFSSSSFSSFSSSSSSSFSSSSSSSFSSSSSFFSFFFSFFS...

output:

854698427

result:

ok 1 number(s): "854698427"

Test #16:

score: 0
Accepted
time: 248ms
memory: 43480kb

input:

199981
SFFSSFSSFSSSFSSSFSSFSFSSFFFFFFFFSFFFFFSFFFSSFSFSFFSSFSFFFFFSFFFFSSSFFSSFSSFSSSFFSFFSSSFFSSSFSFSSFFFSSFFFSSSSFFSFSFFSFSSFSFSFSFSSSSFFSSSSFSSFSSSSFSFSSSFSFSFFFSSSFSFSFFFFSSSSSSFFSSFSSFSFSFFSFFSSSSSSFFSFFSFFSSFFSFSFSFSFSSSFFSFFFSSFFSSFFFFSSFSSFSSSSSFFSSSFFSSFFSFFFSSSSSFSSFFSFSFFSFFSFSSSFFFSFSSSS...

output:

990783292

result:

ok 1 number(s): "990783292"

Test #17:

score: 0
Accepted
time: 233ms
memory: 39432kb

input:

199982
SFFSSSFSFSSSFFFFSSFFFFSFSSSSFFFSFSFFSSFFSSFSSSFSFSFSSFFSSSSSFSSFSFFFSSFSFSSSSSSFSSFSFSFSFFSSSSFSFSSSSFSSSSSFSSSSSSFSFFSFSSSFSFSSSFFFSFSSSFSSSFFFSSFFSSFSSFSFFSSSSSFSSSFFSFSFSFSFSFFSSFFSFFFSSSFSFFFSFFSSSFSSSFSSSFSFSSSFFSSSSFSFSFFSFFSFSSFSSFFFSFFFSFFFSSFSFFSFSSSFSSFFSSFSSFSSSSSSSSFFFSSFFFFSFFSSF...

output:

535880887

result:

ok 1 number(s): "535880887"

Test #18:

score: 0
Accepted
time: 254ms
memory: 43472kb

input:

199983
SSFSFFSSSFFFFSSSSSFSFFFSFSFFSFSSSSSFSFFSFSSFFSSSFFFSFFFSFFFFSFFSFFSFFSSSSSSSSFFSFSSFSSFSFFFSFFSFFSSSFFFFFSFSSFSFFFFFSFFFFFSSSFSFSFSSSSSFSSFSSSSSFSSSFSFSSSFFFFSSFSSFSSSSSFFFFSSFFSSSSSSFFSSFFSFFFSFFSFSFSFFSFFFSFSFFFSFSSFFSFFFSSSFSFFSSSSFSSSFFSSFSFSFFFFFFFSSSSSFFFSSSSSSSSFFFFSFFSSSFSSFSFSFSSFSFS...

output:

29372676

result:

ok 1 number(s): "29372676"

Test #19:

score: 0
Accepted
time: 230ms
memory: 44132kb

input:

199984
SSSFFSSSSFFFFFFFFFFFSSSFSSSSSSSFSSFFSSFFSFFFFFSSFSFFFFFSSSSFFSSSSSFSSSFSFSFFSSSSFSSFFSSFFSFFSSSFSFSFSFSSFSSFFFFSFFFSSSSSFFSSSFSFFFSSFFFSFFSFSSSSFSFSSFSFSFSFFFSSFFFFFFFFSSFSFFFSFSSSSFFSFSSFSFSFSFSFSSSSSSSFFFSFSSSFFSSFFFFSSFSSFFSFFSSSSFFFFFSSSSSFFFSSSFSSFFSFFSFFSFSFSSSSFFSFSSFSFFFSSSFFFFFFSFSFF...

output:

525200447

result:

ok 1 number(s): "525200447"

Test #20:

score: 0
Accepted
time: 223ms
memory: 40504kb

input:

199985
SSSFSSFSFFFFSFSFFFFSFSSSFSFFSSSFFFSFSFSFSFSSSFFSFSFFSSFFFFFFFFFSFFSSFSSFSFSFSFFSSSFFSSSFSFFFFFFFSSSFFFFFSSSSFSFFFSFFFSSSSSSSSFFSFFSSFFFSSSFSSFFFSSFFSFSFSSSFSFFSSFFFFSFFSFSSSSFSFFSSSSSFFSFSFFFSSSFFSSSFFFSSFSFFFSFFFFFSFFSFFSSSFSFFFSSSFSSFFFSSFFSSFSSSSFFFFFSSFFSFSFFFSSFFFFFSFSSFFFFSSSFFFSFFSFSFF...

output:

497376383

result:

ok 1 number(s): "497376383"

Test #21:

score: 0
Accepted
time: 261ms
memory: 51764kb

input:

199986
SFSSSFSSFFSSSSFSFFFFFSFSSFFSFSSSSFSFFSSSFSFSFSFSFFSFFSFFFSSFSSSSSFSSSSSFFFSFFSSSFSFFSSSSSFFSFSSFSSSFSFSFSSFFSFSFFFFSFFFSSSFSFFFSFSSSFSFFFSSFSSSSFSSSFFSFFFFFSFFSFFSSSSSSSFSSSFSFSFSSSSFSFSSFSSSFFSFFFFFSFFFSFSSSSSSFSFSFSSFFSSFSSSFFSFSFFFSFFSSSFFFFSFFSFFFSFSFSSFFFFSSSSSSFFFSSSSFSFSSFFSFSFFSFFFFSS...

output:

494235109

result:

ok 1 number(s): "494235109"

Test #22:

score: 0
Accepted
time: 247ms
memory: 43836kb

input:

199987
FFFSSSSSSSSSSFSFSFFFSFSFFFSFFSSSFFFSFFFFSSSFFSSSFSSFSSFSSFFFFSFSSSFFFSFFSFFFFFFSFSFFFSSSSSFSSFFSSFSFFFFSFSSSSFSSFFFFFFFSFFFSFSFSFSSFSFSSFFFSSSFSFFSFSFFFFSSFSSFSFFFSSFSFSSFFFSSFSSFSSFFFFSSFFSFFSFSFFFFFFSSFFSFSFSFFSFFSFSFFFFSSSFSSSFSFFSSFSFFFSSFSSSFFSSSFFFFFSFFFSSSFSSSFFFFSFSSFFSFFFSFFFSSFFFFSF...

output:

390614605

result:

ok 1 number(s): "390614605"

Test #23:

score: 0
Accepted
time: 235ms
memory: 43236kb

input:

199988
FFFSFFFSSSFSSSFSSFFSSFFSSFFSFFSSSSSSFSFFFFFFSSSSFSSFSFFSFSSSFFFFFFSFSSSSFSSSFSSSSFSFSSSFFFFFFSSSFSSFSSSFFSFFFSFFFSFSSSSFFFFFFSFFSSFFSSSSSSSSSFSFSFFSFFFFFSSFSSFSSSFSFSFFSSFFFFFFSFFSSSSSFSFSSFFSSSSFFFFSSSFSFFSFFSSFSSFSSFSSSFFSFSSSSSFFSFSFSFFFSSSFFFSFFSFSSSFSFFSFFSFFSSFFFSSFSSFSFFFFSSFSSFSSSFFFF...

output:

808212748

result:

ok 1 number(s): "808212748"

Test #24:

score: 0
Accepted
time: 262ms
memory: 44472kb

input:

199989
FSFFFSSSFSFFFSSFFSFFFFFFFFSFSFSFFSFSFFSSSFSFFFSSFFFSFFFSSFFSSSSFSFFFFSFSSSSSFFFSSFSSFSSSFSFFSFFSFFSSFSFSFSFSSFFSFFFFSSSFSSFFFSFFSSFFSFSFFFFFSSFSFFSFFFFFFFFFSSFSSSSFFSSSSFSSSSFSSFFSSSFFFSFFFFSSFFFSFSFFSFSSFFFFSSSFFSSFFFSSFFSSFFFSSSFSSFFFFSSSSFSSFSSFFSFFSSFSSFFFSFFSSSSFSSFFFSSFFFSSSSSSSSSSSFFFS...

output:

245218183

result:

ok 1 number(s): "245218183"

Test #25:

score: 0
Accepted
time: 0ms
memory: 2076kb

input:

20
FFSSFSSSFFFFFSFSSFSF
10 19
9 18
1 4
3 6
16 5
15 18
20 7
10 7
15 13
7 18
12 6
5 15
18 17
14 9
11 10
8 18
5 6
2 15
18 4

output:

30

result:

ok 1 number(s): "30"

Test #26:

score: 0
Accepted
time: 0ms
memory: 2140kb

input:

20
FSFSFFFSFFFSFFSFFFSS
8 6
6 18
16 8
7 8
11 1
9 16
3 5
7 11
19 8
13 20
12 1
9 14
4 9
1 15
10 11
7 5
7 17
5 2
13 10

output:

44

result:

ok 1 number(s): "44"

Test #27:

score: 0
Accepted
time: 0ms
memory: 2064kb

input:

20
FSFSSSSSSFSSSFFFFFSF
19 17
16 2
6 14
4 8
13 19
7 9
14 3
5 7
5 12
5 19
2 3
17 6
11 8
15 19
11 5
10 8
2 1
3 20
18 5

output:

101

result:

ok 1 number(s): "101"

Test #28:

score: 0
Accepted
time: 0ms
memory: 2056kb

input:

20
FFFFSFSSSSSSSSSSSFSF
19 16
13 10
10 9
10 18
1 3
8 20
4 16
17 20
16 6
17 15
14 15
12 1
5 18
18 2
11 7
1 15
11 12
10 15
16 15

output:

405

result:

ok 1 number(s): "405"

Test #29:

score: 0
Accepted
time: 0ms
memory: 2072kb

input:

20
FFSFFFFSFSFFSFFFSSSS
6 15
4 8
6 14
12 14
2 7
13 4
1 4
12 16
10 16
14 13
5 15
17 16
14 18
9 14
14 20
16 2
11 6
3 6
11 19

output:

81

result:

ok 1 number(s): "81"

Test #30:

score: 0
Accepted
time: 0ms
memory: 2004kb

input:

20
FFSSFSSSFSFFSSSSSSFF
12 9
12 7
4 8
12 19
8 12
17 19
6 10
1 13
15 5
18 10
16 9
17 15
2 9
3 18
8 11
20 10
13 15
8 6
2 14

output:

129

result:

ok 1 number(s): "129"

Test #31:

score: 0
Accepted
time: 0ms
memory: 2068kb

input:

20
FSSSSFSSSSFFFFFFFSFS
2 14
17 10
5 3
15 16
19 1
9 10
19 15
11 2
12 11
16 4
13 20
8 7
18 20
15 18
6 4
14 16
5 15
9 16
8 14

output:

21

result:

ok 1 number(s): "21"

Test #32:

score: 0
Accepted
time: 0ms
memory: 2000kb

input:

20
FSFSSSFSSFSSFFSSFSFS
16 9
8 10
11 13
12 11
3 19
16 14
8 12
7 18
5 8
19 2
20 7
4 18
17 20
14 11
6 20
9 15
19 12
18 11
1 16

output:

129

result:

ok 1 number(s): "129"

Test #33:

score: 0
Accepted
time: 0ms
memory: 2128kb

input:

20
FSFFSFSSFFSSFSFFSFFF
12 20
2 6
13 15
8 2
4 19
10 1
11 15
11 2
1 7
3 4
18 6
10 4
2 4
12 9
14 8
17 5
5 10
9 16
10 12

output:

1366

result:

ok 1 number(s): "1366"

Test #34:

score: 0
Accepted
time: 0ms
memory: 2136kb

input:

20
FFFFFSSFFSSFFFFSFSSF
6 7
7 16
14 7
8 13
17 19
1 15
4 2
5 1
6 3
7 17
12 15
3 10
7 20
8 14
9 15
3 18
11 7
4 19
7 5

output:

58

result:

ok 1 number(s): "58"

Test #35:

score: 0
Accepted
time: 1ms
memory: 2672kb

input:

4269
SFFFSFSSSSFFFFSFFFSFFSSFSFSSFSSSFSFFFSFSFSSFFFSFFSFFSFSSSFFSSSSFSFFFFFFFSFSSFFFSFFSFFFFSFFFFFSSFFSFFFFSSSFSSSSSFFFSSSSFFFSSFFFSSSSSSFFSFSSSFFFSSSSFSFSSFFFSSFSFSSSSFFFSSSFFFSSSFSSFFSSSSSSFFFFSFFSSSSFFSSSFFFFSFFFFSSFFSFFFSFSFFSFFFFFFSFSSSSFSFSFSSSFFSFFFSSSSFSFFFSSSSSFFSSSSFSSFSSSFSFFFSFSSFFSSFFFF...

output:

159892112

result:

ok 1 number(s): "159892112"

Test #36:

score: 0
Accepted
time: 1ms
memory: 2864kb

input:

4269
SFSFFSFSFFFFSSFSSFSSSSFSFFFFFSSSSSFFFFFFSFFSSFSFFSFFFSSSFSSFFFFSFSSFSFFFFSFSSSSSFFSFFFFFSSFFFFFSFSFSSFFFSFFFSFSSFFFSFFSFFFSFFFFSSSSSFSFSSFFFFFFFSFSFSSFSFSSSFFFSFSSFSSFSSSFFSFFFFFFFSFFFSSSSSFFFFFFSSFFFFFSSFFFFSFSSSFSFSFSSSFSFSSFSFSFFFSSSSFFFFSSFSSFSSFSFSFSSSFFFFSSFSFSSSSFSFSSFSSSFFFSFSFSFSSSFFFF...

output:

856340324

result:

ok 1 number(s): "856340324"

Test #37:

score: 0
Accepted
time: 1ms
memory: 2728kb

input:

4269
SFSSFFFSFFSFSSSFSFSSSSFSSFSSSSSFFSSFFSSSSFSSFSFFFFSSSSSSSFFFFSSSSFSSFFSSSSFSSFFSSFFFSSSFSFFSSSSSFFFSFFSSFFSSFSFSFSFFFFFFSFSFFSFSFFSFSFFSFSSSFSSFFFSSFSFSFFFSFFFSSSFFSFFFSSSFSSFFFSSFSSSSSSSSFSSSSFSFFSSSFFFFFSSSFFFSFFFSFSSSFFFFFFSSFSSFSFFSFSFSFSFSFFSSFSSSSSFSFSSFSFFSSFFSFSSSSSFSSFSFSFSSSSSFSSSFSSF...

output:

812166003

result:

ok 1 number(s): "812166003"

Test #38:

score: 0
Accepted
time: 1ms
memory: 2796kb

input:

4269
SSSSFSSSSFSSSFFSFFSFFFSFFSFFSSFFSFFFFFSSFSFFFSFFFSSSFSSFFSSFSFFSFFFSSFFSFSSSSSSSFSFFFSSSSFFSFFSSFSFSSFFFFFSFSSFFSFFSSSFSSSSFFSFFFFSFSSFFSFSFFFFSSFFFFSFSFSSSFFFSSFSSFSSSSFSSFFSSFSSFSSFFSSFFSSFSSSSFFSSFFSSFSSFSSFSSFFSFSSFFSFSFFSFSFFSFSSFSFFSSSFFFFSSFFSFFSSFFSSFSFFSSSSFFFSFSFSSFFSFSSFSFSFSSFFSSFSS...

output:

913190270

result:

ok 1 number(s): "913190270"

Test #39:

score: 0
Accepted
time: 1ms
memory: 2744kb

input:

4269
SSFSSSFSFFFSSSSFFSSSFFFSSSFSSFFSFFSSSSFFSSSFSFSFFFSSFFSFFFFFFSFSSSSSFFSSFFSSSFFFFSFSSSSSFSFFSSFSSFFSFFFSFFFSSFFSSFFFSSSSFSSSSSFFFFSFSFFSFSFSFFSFSFSSSFSSSFSSFSSSFFSSFSFSSSFSFSSSFFSFSFSSSFFSFFSFFFFFFSSSSFFSSSSFFFFSFSFFFSFFFSSFSFFFSFSSSFFFSFSFSSSSSFFFSSSSFFFSSSFSSSSFSSSFFSSFSSFSFSSSFFSSSSSSFFSSSSS...

output:

963325596

result:

ok 1 number(s): "963325596"

Test #40:

score: 0
Accepted
time: 95ms
memory: 33356kb

input:

199980
SFSFFSSSSSFSSSFFFSSSSFFSSFSSSSFFFFSSFFSSFFFFSFSSFFSSSSSFFFSSSSFFFFFFFSFFSFSSSFSFFFFSFSFFSFSFFSFSFSFSFFSSSSFFSSFSSFFFFSFSFFFFFSSSFSFFFFFFSFFSSSFFSSSFFSSSFSFSFSSSFSSSFSSSSSFSFFFSSSFSSSFFSFSFSFFFSSSSFSSSFSSFSSSFFFFFSFFSFFFFSSSFFSSFFSSSFSSSFSSSFSSFSFSSFSFSFFSSSSFSSFSSSSSSSFSSSSSSSFSSSSSFFSFFFSFFS...

output:

131662118

result:

ok 1 number(s): "131662118"

Test #41:

score: 0
Accepted
time: 106ms
memory: 33164kb

input:

199981
SFFSSFSSFSSSFSSSFSSFSFSSFFFFFFFFSFFFFFSFFFSSFSFSFFSSFSFFFFFSFFFFSSSFFSSFSSFSSSFFSFFSSSFFSSSFSFSSFFFSSFFFSSSSFFSFSFFSFSSFSFSFSFSSSSFFSSSSFSSFSSSSFSFSSSFSFSFFFSSSFSFSFFFFSSSSSSFFSSFSSFSFSFFSFFSSSSSSFFSFFSFFSSFFSFSFSFSFSSSFFSFFFSSFFSSFFFFSSFSSFSSSSSFFSSSFFSSFFSFFFSSSSSFSSFFSFSFFSFFSFSSSFFFSFSSSS...

output:

357767781

result:

ok 1 number(s): "357767781"

Test #42:

score: 0
Accepted
time: 113ms
memory: 33120kb

input:

199982
SFFSSSFSFSSSFFFFSSFFFFSFSSSSFFFSFSFFSSFFSSFSSSFSFSFSSFFSSSSSFSSFSFFFSSFSFSSSSSSFSSFSFSFSFFSSSSFSFSSSSFSSSSSFSSSSSSFSFFSFSSSFSFSSSFFFSFSSSFSSSFFFSSFFSSFSSFSFFSSSSSFSSSFFSFSFSFSFSFFSSFFSFFFSSSFSFFFSFFSSSFSSSFSSSFSFSSSFFSSSSFSFSFFSFFSFSSFSSFFFSFFFSFFFSSFSFFSFSSSFSSFFSSFSSFSSSSSSSSFFFSSFFFFSFFSSF...

output:

927723161

result:

ok 1 number(s): "927723161"

Test #43:

score: 0
Accepted
time: 99ms
memory: 33364kb

input:

199983
SSFSFFSSSFFFFSSSSSFSFFFSFSFFSFSSSSSFSFFSFSSFFSSSFFFSFFFSFFFFSFFSFFSFFSSSSSSSSFFSFSSFSSFSFFFSFFSFFSSSFFFFFSFSSFSFFFFFSFFFFFSSSFSFSFSSSSSFSSFSSSSSFSSSFSFSSSFFFFSSFSSFSSSSSFFFFSSFFSSSSSSFFSSFFSFFFSFFSFSFSFFSFFFSFSFFFSFSSFFSFFFSSSFSFFSSSSFSSSFFSSFSFSFFFFFFFSSSSSFFFSSSSSSSSFFFFSFFSSSFSSFSFSFSSFSFS...

output:

120451617

result:

ok 1 number(s): "120451617"

Test #44:

score: 0
Accepted
time: 115ms
memory: 33140kb

input:

199984
SSSFFSSSSFFFFFFFFFFFSSSFSSSSSSSFSSFFSSFFSFFFFFSSFSFFFFFSSSSFFSSSSSFSSSFSFSFFSSSSFSSFFSSFFSFFSSSFSFSFSFSSFSSFFFFSFFFSSSSSFFSSSFSFFFSSFFFSFFSFSSSSFSFSSFSFSFSFFFSSFFFFFFFFSSFSFFFSFSSSSFFSFSSFSFSFSFSFSSSSSSSFFFSFSSSFFSSFFFFSSFSSFFSFFSSSSFFFFFSSSSSFFFSSSFSSFFSFFSFFSFSFSSSSFFSFSSFSFFFSSSFFFFFFSFSFF...

output:

423303699

result:

ok 1 number(s): "423303699"

Test #45:

score: 0
Accepted
time: 109ms
memory: 33208kb

input:

199985
SSSFSSFSFFFFSFSFFFFSFSSSFSFFSSSFFFSFSFSFSFSSSFFSFSFFSSFFFFFFFFFSFFSSFSSFSFSFSFFSSSFFSSSFSFFFFFFFSSSFFFFFSSSSFSFFFSFFFSSSSSSSSFFSFFSSFFFSSSFSSFFFSSFFSFSFSSSFSFFSSFFFFSFFSFSSSSFSFFSSSSSFFSFSFFFSSSFFSSSFFFSSFSFFFSFFFFFSFFSFFSSSFSFFFSSSFSSFFFSSFFSSFSSSSFFFFFSSFFSFSFFFSSFFFFFSFSSFFFFSSSFFFSFFSFSFF...

output:

525376118

result:

ok 1 number(s): "525376118"

Test #46:

score: 0
Accepted
time: 86ms
memory: 33272kb

input:

199986
SFSSSFSSFFSSSSFSFFFFFSFSSFFSFSSSSFSFFSSSFSFSFSFSFFSFFSFFFSSFSSSSSFSSSSSFFFSFFSSSFSFFSSSSSFFSFSSFSSSFSFSFSSFFSFSFFFFSFFFSSSFSFFFSFSSSFSFFFSSFSSSSFSSSFFSFFFFFSFFSFFSSSSSSSFSSSFSFSFSSSSFSFSSFSSSFFSFFFFFSFFFSFSSSSSSFSFSFSSFFSSFSSSFFSFSFFFSFFSSSFFFFSFFSFFFSFSFSSFFFFSSSSSSFFFSSSSFSFSSFFSFSFFSFFFFSS...

output:

46878101

result:

ok 1 number(s): "46878101"

Test #47:

score: 0
Accepted
time: 108ms
memory: 33144kb

input:

199987
FFFSSSSSSSSSSFSFSFFFSFSFFFSFFSSSFFFSFFFFSSSFFSSSFSSFSSFSSFFFFSFSSSFFFSFFSFFFFFFSFSFFFSSSSSFSSFFSSFSFFFFSFSSSSFSSFFFFFFFSFFFSFSFSFSSFSFSSFFFSSSFSFFSFSFFFFSSFSSFSFFFSSFSFSSFFFSSFSSFSSFFFFSSFFSFFSFSFFFFFFSSFFSFSFSFFSFFSFSFFFFSSSFSSSFSFFSSFSFFFSSFSSSFFSSSFFFFFSFFFSSSFSSSFFFFSFSSFFSFFFSFFFSSFFFFSF...

output:

995576278

result:

ok 1 number(s): "995576278"

Test #48:

score: 0
Accepted
time: 94ms
memory: 33428kb

input:

199988
FFFSFFFSSSFSSSFSSFFSSFFSSFFSFFSSSSSSFSFFFFFFSSSSFSSFSFFSFSSSFFFFFFSFSSSSFSSSFSSSSFSFSSSFFFFFFSSSFSSFSSSFFSFFFSFFFSFSSSSFFFFFFSFFSSFFSSSSSSSSSFSFSFFSFFFFFSSFSSFSSSFSFSFFSSFFFFFFSFFSSSSSFSFSSFFSSSSFFFFSSSFSFFSFFSSFSSFSSFSSSFFSFSSSSSFFSFSFSFFFSSSFFFSFFSFSSSFSFFSFFSFFSSFFFSSFSSFSFFFFSSFSSFSSSFFFF...

output:

140483963

result:

ok 1 number(s): "140483963"

Test #49:

score: 0
Accepted
time: 106ms
memory: 33144kb

input:

199989
FSFFFSSSFSFFFSSFFSFFFFFFFFSFSFSFFSFSFFSSSFSFFFSSFFFSFFFSSFFSSSSFSFFFFSFSSSSSFFFSSFSSFSSSFSFFSFFSFFSSFSFSFSFSSFFSFFFFSSSFSSFFFSFFSSFFSFSFFFFFSSFSFFSFFFFFFFFFSSFSSSSFFSSSSFSSSSFSSFFSSSFFFSFFFFSSFFFSFSFFSFSSFFFFSSSFFSSFFFSSFFSSFFFSSSFSSFFFFSSSSFSSFSSFFSFFSSFSSFFFSFFSSSSFSSFFFSSFFFSSSSSSSSSSSFFFS...

output:

85945824

result:

ok 1 number(s): "85945824"

Test #50:

score: 0
Accepted
time: 108ms
memory: 33344kb

input:

199990
FSSFFFFFFSSFFFFFFFFSFSFSSFSSFFFFSSFFFSFFFFFFSSSFSSFFFSFFSFFFFSSSSSSFSFFFSFSSSSSSSFSSSSFSFSFFSSSSFSSSSSFSSSSFFFSFSSSSSSFSFSFSFSFSFSSFSSFSFSSFSSFSSFSSSFFSFFFSSSFSFFSSSSFFFSSSFSFFSFSSSSSFSFFFFFSFSFSFSSSSSSSSSSSFSFSFFFFSFSFSFSFSSSSFFSFSSFFSSFFFFFFFSFSSFSSFFFSFFSFFSFFFSSFFSSFFSSSSFSFFFSFFFSFSSFSFF...

output:

837172100

result:

ok 1 number(s): "837172100"

Test #51:

score: 0
Accepted
time: 117ms
memory: 33276kb

input:

199991
FFSFFSSSFSFSSFSSSFSFSFSFFFFFFFFFFSSFSFSSSSSSSFSFSFSFSSFFFSSSFSFSFFFFFFFSFSFSSFFSSFSSFSSFSSFSFFFSFFSSFSSFFSSSFFSSSFSFSFFFFSSFFSFSFSSFSFFFSFFFSFSFSSSFFFFFFSFSSSFSFFFSSFSFFSSSFFFFSSSSSFFFSSFSSFFSFFFFSSSFSFFSSSFSFFFFFFSFSSFSSSSFFSFFFFFFFSFSFSFFSSFSSSFFSSFSFSSSSSSFFSSFSSSFSSSFFSFFFFFFFSFSFFSSSFSFS...

output:

582784115

result:

ok 1 number(s): "582784115"

Test #52:

score: 0
Accepted
time: 116ms
memory: 33156kb

input:

199992
FFFSFFSSSFFSSSFFSSSFFFSFSFFSSFFFSFFFSSSFFSFSFFFFSFSFFSFSSFSSSFFSSSSFSFSSSSFFSSSSFFFSSSSFSFFSSSFSSSSFSFFSFSFFSSFSSFSSFFSFSFSFFSFFSSSSSSSSFSSSSSFFFSFSFFSFFSSSSSFSSFSFFSFSFFFFSSSFSSSSSFSSSSSSFSSSSSFFSFSSFSSFSSSSSFSFSSSSFFSFFSFFFFSSFFFFFFFFFFSSSSSFSSFFFSFFFFSFSSFSSSFSSSFFSSFSSSSSFFSSSSFFFSSFSFSSF...

output:

459791581

result:

ok 1 number(s): "459791581"

Test #53:

score: 0
Accepted
time: 107ms
memory: 33272kb

input:

199993
FFFSSSFSSFSSSFSSSSSSFFFSFSSSSSFSFFFSSFFFSFSFSFFFSSSSSFFSSSFSFSSSFSFFFFFSFSSFSFFSSFFSFSSSSSFFSFSFSSSFFFSFSSSSFFFFSSSFFSSFSFSFFSFFSFSSFFSSSFFFSSSSSSFFSFSFFFFSSFSSFFSFFSFFFSFFSFSSFFSSSSFFSSSFSFFFSFSFFFSFFSFSSFFSFFFFSSFFSFSFSFSFSSSSFSSFFSFFFFSSSFSSFFFFFFSSSSFSFSFSFFFFSSFFSSSSFSFSFSFSSSFSSFSFFSSSF...

output:

632483050

result:

ok 1 number(s): "632483050"

Test #54:

score: 0
Accepted
time: 112ms
memory: 33212kb

input:

199994
FSFSSSSSFFSFSSFFFSSFSFSFSSFFSSFSFFSSSSFSSFFFSSFFSFSSSFFFFFSSSFFFSFSSSFSFSFSFFSSFSSFSSSSSFSFFFSFFSFSFSFFSSSFFFFFSSFSSFSFFFSSFFFFFSFSSFFSFSFSSSFFFSSSSFSSFSSFSSFSFFFFFSFSSFSSFFSSSFSFSSFSSSSFSFFSFFSSFFFSSSFFSSFSFSFSFSSSSFSFFFFFFSFFSSSSSSSSFSSSFFFFFFSSSSFFFSSFSFSSSSFSSSSSSFSFSSSSFFSFFFSSSSSSFFSFSS...

output:

198965372

result:

ok 1 number(s): "198965372"

Test #55:

score: 0
Accepted
time: 94ms
memory: 33328kb

input:

199995
FSSFFFSSSFSFFSSSFSSSSSFSFSSSFSFFSSFSFSFFFSSSFSSFSFFSFFFFSSFFSSSFFSFSFFFFFFFFFFFFFSSSFSSFFFSSSFSFSSSFFFSFFSFSSSSFSFSFSFSSFFSFSFFSFFSSFSSSFSFFSSSFFSFFFSFFSFSFSFSFSSSFSSSSFFSSFFFFFSFSSSFFSSSSSSSSFFFSFSFFSSSFSFFFFFSFFFFSSSSSSSFFFSFFSFSSSFSFSFFFFSFSSFSSFFFSSFFFSSFSFFFSSSFSFSSFFSFSFFSFFSSFSFSSSSFFF...

output:

553909431

result:

ok 1 number(s): "553909431"

Test #56:

score: 0
Accepted
time: 119ms
memory: 33296kb

input:

199996
FSSFFSFSSSFFFFFFSFSSFSFFSSFFFFFFFSSSFFSFSSFSSFSFSSFSSSFFFFSFFFFFFSSSSFFFSFSSFSSFFSSFSFFSSSSSFSFFFFSFSFFSFSSFSFSSSSSFSFSSSFFSSFSSFSFFSFFSSFSFSSFSSSFSSSFFSSFFFFSFFSFSFSFFFSFSSSFFSFFSSSSSSSSFSSFSSFSSSSFSSSFSSSFSFFFFFFSFFSSSFSSFFFSFSFSFSSSFSFFSSSSFSSFSFSSFSSFSFFFSSSFFSSFSFSFFSSSFFFFSSSSSSSFSSSFFF...

output:

532351273

result:

ok 1 number(s): "532351273"

Test #57:

score: 0
Accepted
time: 114ms
memory: 33172kb

input:

199997
FFSSSFSSFSFSFSSSSFSFFSSFFFSSFFSSSSSSFSSSFFSSSFFFSFFSFSFSSSFFSSSFSFFFFFSSFFSSFFFFSSSFFFFSSSSFFFSSFFSSSFSFFSFSFSFSFFSSFSFSSSFSSFSSFSFFSSFFFSFSSFSFFSSSFSFFSFFFFSSFFSFSFFFSFSFFSFSFSFFSSFFFSSFSFFSFSSSSSFFFFFSSSSSSSSSFFFFSSFFFSSFFSFSFSSSFSFSFFSSSSFSFSFFFSSFSSFFSFFSSFSSSSSSSFSSSFSSSFSFSSSSFSFFSSSFSS...

output:

320626910

result:

ok 1 number(s): "320626910"

Test #58:

score: 0
Accepted
time: 108ms
memory: 33212kb

input:

199998
FFFSSSSSFSSSFFFFFFSSSSFSSFFFSFSSFFFSFFFFSFFFFFFFSSSFFSFSFFSFSFSFFSSFSFFSFSFSFSFFSSFFSFFFSFSFSSSSFSSSFFFSSSSFFSFFFFSFFFFFFSFSSFSFSSFFSSFSFFSFSSFSFSSFSSSSFSSFFSSFSSSSSSSSFFSFFSSSSSSSSSSSSFFSSFFFFFFSSFFSFFFFSSFFFSFFSSFFFFFFFFSFSSFSSSSFFSFSFFSSSSFSFSFFFSSFSFFFSFFSSFFSSSSSSSFSSSFFFSSFSSSSSFFFFSFSF...

output:

318058822

result:

ok 1 number(s): "318058822"

Test #59:

score: 0
Accepted
time: 82ms
memory: 33272kb

input:

199999
FSFSFSFSSFSSSFSSFFSFSFFFFFFSSFSSSFSFSSFFSSSFSSSFSSSFSFFSFSFFFFFFSFFFSFSSSSSSFFSFFSFFFFFFFSSSFFFSFFSSSFSFSSSSSFSSFSFSFFSFSFFSSFSFSSFFSFSSSSSSSSSSSFFSSSSSFSFFFSFFSFFFSFFFFFSFFFFSSSSSSSFFFFSFFSSSFSFSSFFFFSSFSFSFSSSFSSSSFSSFSFFSFFFSSFSSFFFSFSFFFSFFFFSFSFSSSSSSSFFSSFFFSSFSSSSSFSSSFFFFFSFSSSFFFSFFS...

output:

565502702

result:

ok 1 number(s): "565502702"

Test #60:

score: 0
Accepted
time: 109ms
memory: 33240kb

input:

200000
SFSSSSFSFFSFFFSFSFSSSSSSSSFFSSSFFSFFSSFFFFFFFFFFSSFFFFFFFSFFSFFFFFSSSFFFSFFSFFFFFSSFFSFFFFSSSFSFFSFSSFSFFFFFFFSFFSSFSSFSSFFSSFSSSSSFSSSSFFSFFFFFSSFSFFSFFFSSSSFFSFFFFFSSSSSSFFFSFFSFFFSFFFFFFSSSFSFFFFFSFSSSFFSSSFSFSFSSSFFFFFSSFFFSFSFFFSFSSSSSFSFFSFSSFFSSFSFFFFFSSFSFSFFFSSSFSFFFFSSSSFFFSSFFSFSFS...

output:

287002924

result:

ok 1 number(s): "287002924"

Test #61:

score: 0
Accepted
time: 2ms
memory: 3256kb

input:

4269
SFFFSFSSSSFFFFSFFFSFFSSFSFSSFSSSFSFFFSFSFSSFFFSFFSFFSFSSSFFSSSSFSFFFFFFFSFSSFFFSFFSFFFFSFFFFFSSFFSFFFFSSSFSSSSSFFFSSSSFFFSSFFFSSSSSSFFSFSSSFFFSSSSFSFSSFFFSSFSFSSSSFFFSSSFFFSSSFSSFFSSSSSSFFFFSFFSSSSFFSSSFFFFSFFFFSSFFSFFFSFSFFSFFFFFFSFSSSSFSFSFSSSFFSFFFSSSSFSFFFSSSSSFFSSSSFSSFSSSFSFFFSFSSFFSSFFFF...

output:

988025762

result:

ok 1 number(s): "988025762"

Test #62:

score: 0
Accepted
time: 3ms
memory: 2972kb

input:

4269
SFSFFSFSFFFFSSFSSFSSSSFSFFFFFSSSSSFFFFFFSFFSSFSFFSFFFSSSFSSFFFFSFSSFSFFFFSFSSSSSFFSFFFFFSSFFFFFSFSFSSFFFSFFFSFSSFFFSFFSFFFSFFFFSSSSSFSFSSFFFFFFFSFSFSSFSFSSSFFFSFSSFSSFSSSFFSFFFFFFFSFFFSSSSSFFFFFFSSFFFFFSSFFFFSFSSSFSFSFSSSFSFSSFSFSFFFSSSSFFFFSSFSSFSSFSFSFSSSFFFFSSFSFSSSSFSFSSFSSSFFFSFSFSFSSSFFFF...

output:

149785076

result:

ok 1 number(s): "149785076"

Test #63:

score: 0
Accepted
time: 3ms
memory: 3012kb

input:

4269
SFSSFFFSFFSFSSSFSFSSSSFSSFSSSSSFFSSFFSSSSFSSFSFFFFSSSSSSSFFFFSSSSFSSFFSSSSFSSFFSSFFFSSSFSFFSSSSSFFFSFFSSFFSSFSFSFSFFFFFFSFSFFSFSFFSFSFFSFSSSFSSFFFSSFSFSFFFSFFFSSSFFSFFFSSSFSSFFFSSFSSSSSSSSFSSSSFSFFSSSFFFFFSSSFFFSFFFSFSSSFFFFFFSSFSSFSFFSFSFSFSFSFFSSFSSSSSFSFSSFSFFSSFFSFSSSSSFSSFSFSFSSSSSFSSSFSSF...

output:

284273231

result:

ok 1 number(s): "284273231"

Test #64:

score: 0
Accepted
time: 3ms
memory: 3068kb

input:

4269
SSSSFSSSSFSSSFFSFFSFFFSFFSFFSSFFSFFFFFSSFSFFFSFFFSSSFSSFFSSFSFFSFFFSSFFSFSSSSSSSFSFFFSSSSFFSFFSSFSFSSFFFFFSFSSFFSFFSSSFSSSSFFSFFFFSFSSFFSFSFFFFSSFFFFSFSFSSSFFFSSFSSFSSSSFSSFFSSFSSFSSFFSSFFSSFSSSSFFSSFFSSFSSFSSFSSFFSFSSFFSFSFFSFSFFSFSSFSFFSSSFFFFSSFFSFFSSFFSSFSFFSSSSFFFSFSFSSFFSFSSFSFSFSSFFSSFSS...

output:

501945813

result:

ok 1 number(s): "501945813"

Test #65:

score: 0
Accepted
time: 0ms
memory: 2908kb

input:

4269
SSFSSSFSFFFSSSSFFSSSFFFSSSFSSFFSFFSSSSFFSSSFSFSFFFSSFFSFFFFFFSFSSSSSFFSSFFSSSFFFFSFSSSSSFSFFSSFSSFFSFFFSFFFSSFFSSFFFSSSSFSSSSSFFFFSFSFFSFSFSFFSFSFSSSFSSSFSSFSSSFFSSFSFSSSFSFSSSFFSFSFSSSFFSFFSFFFFFFSSSSFFSSSSFFFFSFSFFFSFFFSSFSFFFSFSSSFFFSFSFSSSSSFFFSSSSFFFSSSFSSSSFSSSFFSSFSSFSFSSSFFSSSSSSFFSSSSS...

output:

699376251

result:

ok 1 number(s): "699376251"

Test #66:

score: 0
Accepted
time: 249ms
memory: 44604kb

input:

199990
FSSFFFFFFSSFFFFFFFFSFSFSSFSSFFFFSSFFFSFFFFFFSSSFSSFFFSFFSFFFFSSSSSSFSFFFSFSSSSSSSFSSSSFSFSFFSSSSFSSSSSFSSSSFFFSFSSSSSSFSFSFSFSFSFSSFSSFSFSSFSSFSSFSSSFFSFFFSSSFSFFSSSSFFFSSSFSFFSFSSSSSFSFFFFFSFSFSFSSSSSSSSSSSFSFSFFFFSFSFSFSFSSSSFFSFSSFFSSFFFFFFFSFSSFSSFFFSFFSFFSFFFSSFFSSFFSSSSFSFFFSFFFSFSSFSFF...

output:

572585899

result:

ok 1 number(s): "572585899"

Test #67:

score: 0
Accepted
time: 240ms
memory: 42212kb

input:

199991
FFSFFSSSFSFSSFSSSFSFSFSFFFFFFFFFFSSFSFSSSSSSSFSFSFSFSSFFFSSSFSFSFFFFFFFSFSFSSFFSSFSSFSSFSSFSFFFSFFSSFSSFFSSSFFSSSFSFSFFFFSSFFSFSFSSFSFFFSFFFSFSFSSSFFFFFFSFSSSFSFFFSSFSFFSSSFFFFSSSSSFFFSSFSSFFSFFFFSSSFSFFSSSFSFFFFFFSFSSFSSSSFFSFFFFFFFSFSFSFFSSFSSSFFSSFSFSSSSSSFFSSFSSSFSSSFFSFFFFFFFSFSFFSSSFSFS...

output:

106691066

result:

ok 1 number(s): "106691066"

Test #68:

score: 0
Accepted
time: 256ms
memory: 51828kb

input:

199992
FFFSFFSSSFFSSSFFSSSFFFSFSFFSSFFFSFFFSSSFFSFSFFFFSFSFFSFSSFSSSFFSSSSFSFSSSSFFSSSSFFFSSSSFSFFSSSFSSSSFSFFSFSFFSSFSSFSSFFSFSFSFFSFFSSSSSSSSFSSSSSFFFSFSFFSFFSSSSSFSSFSFFSFSFFFFSSSFSSSSSFSSSSSSFSSSSSFFSFSSFSSFSSSSSFSFSSSSFFSFFSFFFFSSFFFFFFFFFFSSSSSFSSFFFSFFFFSFSSFSSSFSSSFFSSFSSSSSFFSSSSFFFSSFSFSSF...

output:

951998399

result:

ok 1 number(s): "951998399"

Test #69:

score: 0
Accepted
time: 268ms
memory: 51852kb

input:

199993
FFFSSSFSSFSSSFSSSSSSFFFSFSSSSSFSFFFSSFFFSFSFSFFFSSSSSFFSSSFSFSSSFSFFFFFSFSSFSFFSSFFSFSSSSSFFSFSFSSSFFFSFSSSSFFFFSSSFFSSFSFSFFSFFSFSSFFSSSFFFSSSSSSFFSFSFFFFSSFSSFFSFFSFFFSFFSFSSFFSSSSFFSSSFSFFFSFSFFFSFFSFSSFFSFFFFSSFFSFSFSFSFSSSSFSSFFSFFFFSSSFSSFFFFFFSSSSFSFSFSFFFFSSFFSSSSFSFSFSFSSSFSSFSFFSSSF...

output:

716409060

result:

ok 1 number(s): "716409060"

Test #70:

score: 0
Accepted
time: 230ms
memory: 40408kb

input:

199994
FSFSSSSSFFSFSSFFFSSFSFSFSSFFSSFSFFSSSSFSSFFFSSFFSFSSSFFFFFSSSFFFSFSSSFSFSFSFFSSFSSFSSSSSFSFFFSFFSFSFSFFSSSFFFFFSSFSSFSFFFSSFFFFFSFSSFFSFSFSSSFFFSSSSFSSFSSFSSFSFFFFFSFSSFSSFFSSSFSFSSFSSSSFSFFSFFSSFFFSSSFFSSFSFSFSFSSSSFSFFFFFFSFFSSSSSSSSFSSSFFFFFFSSSSFFFSSFSFSSSSFSSSSSSFSFSSSSFFSFFFSSSSSSFFSFSS...

output:

287920786

result:

ok 1 number(s): "287920786"

Test #71:

score: 0
Accepted
time: 250ms
memory: 42088kb

input:

199995
FSSFFFSSSFSFFSSSFSSSSSFSFSSSFSFFSSFSFSFFFSSSFSSFSFFSFFFFSSFFSSSFFSFSFFFFFFFFFFFFFSSSFSSFFFSSSFSFSSSFFFSFFSFSSSSFSFSFSFSSFFSFSFFSFFSSFSSSFSFFSSSFFSFFFSFFSFSFSFSFSSSFSSSSFFSSFFFFFSFSSSFFSSSSSSSSFFFSFSFFSSSFSFFFFFSFFFFSSSSSSSFFFSFFSFSSSFSFSFFFFSFSSFSSFFFSSFFFSSFSFFFSSSFSFSSFFSFSFFSFFSSFSFSSSSFFF...

output:

619531008

result:

ok 1 number(s): "619531008"

Test #72:

score: 0
Accepted
time: 250ms
memory: 43392kb

input:

199996
FSSFFSFSSSFFFFFFSFSSFSFFSSFFFFFFFSSSFFSFSSFSSFSFSSFSSSFFFFSFFFFFFSSSSFFFSFSSFSSFFSSFSFFSSSSSFSFFFFSFSFFSFSSFSFSSSSSFSFSSSFFSSFSSFSFFSFFSSFSFSSFSSSFSSSFFSSFFFFSFFSFSFSFFFSFSSSFFSFFSSSSSSSSFSSFSSFSSSSFSSSFSSSFSFFFFFFSFFSSSFSSFFFSFSFSFSSSFSFFSSSSFSSFSFSSFSSFSFFFSSSFFSSFSFSFFSSSFFFFSSSSSSSFSSSFFF...

output:

11372220

result:

ok 1 number(s): "11372220"

Test #73:

score: 0
Accepted
time: 236ms
memory: 43576kb

input:

199997
FFSSSFSSFSFSFSSSSFSFFSSFFFSSFFSSSSSSFSSSFFSSSFFFSFFSFSFSSSFFSSSFSFFFFFSSFFSSFFFFSSSFFFFSSSSFFFSSFFSSSFSFFSFSFSFSFFSSFSFSSSFSSFSSFSFFSSFFFSFSSFSFFSSSFSFFSFFFFSSFFSFSFFFSFSFFSFSFSFFSSFFFSSFSFFSFSSSSSFFFFFSSSSSSSSSFFFFSSFFFSSFFSFSFSSSFSFSFFSSSSFSFSFFFSSFSSFFSFFSSFSSSSSSSFSSSFSSSFSFSSSSFSFFSSSFSS...

output:

838488621

result:

ok 1 number(s): "838488621"

Test #74:

score: 0
Accepted
time: 217ms
memory: 40340kb

input:

199998
FFFSSSSSFSSSFFFFFFSSSSFSSFFFSFSSFFFSFFFFSFFFFFFFSSSFFSFSFFSFSFSFFSSFSFFSFSFSFSFFSSFFSFFFSFSFSSSSFSSSFFFSSSSFFSFFFFSFFFFFFSFSSFSFSSFFSSFSFFSFSSFSFSSFSSSSFSSFFSSFSSSSSSSSFFSFFSSSSSSSSSSSSFFSSFFFFFFSSFFSFFFFSSFFFSFFSSFFFFFFFFSFSSFSSSSFFSFSFFSSSSFSFSFFFSSFSFFFSFFSSFFSSSSSSSFSSSFFFSSFSSSSSFFFFSFSF...

output:

23711524

result:

ok 1 number(s): "23711524"

Test #75:

score: 0
Accepted
time: 223ms
memory: 39940kb

input:

199999
FSFSFSFSSFSSSFSSFFSFSFFFFFFSSFSSSFSFSSFFSSSFSSSFSSSFSFFSFSFFFFFFSFFFSFSSSSSSFFSFFSFFFFFFFSSSFFFSFFSSSFSFSSSSSFSSFSFSFFSFSFFSSFSFSSFFSFSSSSSSSSSSSFFSSSSSFSFFFSFFSFFFSFFFFFSFFFFSSSSSSSFFFFSFFSSSFSFSSFFFFSSFSFSFSSSFSSSSFSSFSFFSFFFSSFSSFFFSFSFFFSFFFFSFSFSSSSSSSFFSSFFFSSFSSSSSFSSSFFFFFSFSSSFFFSFFS...

output:

217802478

result:

ok 1 number(s): "217802478"

Test #76:

score: 0
Accepted
time: 218ms
memory: 39876kb

input:

200000
SFSSSSFSFFSFFFSFSFSSSSSSSSFFSSSFFSFFSSFFFFFFFFFFSSFFFFFFFSFFSFFFFFSSSFFFSFFSFFFFFSSFFSFFFFSSSFSFFSFSSFSFFFFFFFSFFSSFSSFSSFFSSFSSSSSFSSSSFFSFFFFFSSFSFFSFFFSSSSFFSFFFFFSSSSSSFFFSFFSFFFSFFFFFFSSSFSFFFFFSFSSSFFSSSFSFSFSSSFFFFFSSFFFSFSFFFSFSSSSSFSFFSFSSFFSSFSFFFFFSSFSFSFFFSSSFSFFFFSSSSFFFSSFFSFSFS...

output:

587382866

result:

ok 1 number(s): "587382866"

Test #77:

score: 0
Accepted
time: 4ms
memory: 3244kb

input:

6942
SSSSSFSSFSFFFFSFFSFFSFSSSSFFFSSSSSSSSSSSSFFSSFSSSFSSFSSFSFSFSSFFFSSFFFFSFSFSFFSFSFSSFFFSSSFFFSFFFFFFFFSFSFFSSSFSSFSSFFFSFSSFFFSSFFSFSSFFSFFSSFFSSSSSFFSSSSSFFSSSSSFFFSSFSFSSSSSSFFSFFFSSFSSSSFSSSSSSFFSFSSFFSFSSFFSSFFFSSSSSFSFSFFSFFFSFFSSSSFFFSSFFSSSSSFSSFSFFSFSSSSSSFFSFSFFFSSSSFFFFFSFFSSSSSFSFFFS...

output:

647088399

result:

ok 1 number(s): "647088399"

Test #78:

score: 0
Accepted
time: 4ms
memory: 3384kb

input:

6942
SSFSSSFSSSFSSSFSFFFSSFFFFSSSFSSFFSFSSFSFSFSFFFSSSFSSSSSFFSFFSFFFSSFFSFFSSSSSFSFFSFSSSFFFSFFFSFSFSSFFFFFSFFSFFFSFSSSFSSSSSFSFFFFSFSSFFSFFFSSFSFFFFSSFSFSFSFSFSSSSFFSSSSFSSFSSSFSSFSSFFSFFFSSFFSFSFFSSFFSSSSSSFSFSSFFFFSSFFSFSSFSSSSFFSSSFSFSSSFFFFFSSFFSFSFFSFFFSSFFSSSFFFFSFSFSSFSFFFFFSFSFSSFSSSFSSSFS...

output:

58335146

result:

ok 1 number(s): "58335146"

Test #79:

score: 0
Accepted
time: 4ms
memory: 3176kb

input:

6942
SFFFFFSSSSSSSSSFFFFSFSFSSSFFFSFFSFFSSSFSFSFFSSFSSSSSSFSSSFSFFSSFFFSFFFSSFFFSFFSFFFFSFFFFSSFSFSFFSFFFSFSFFFSSSFSSSFSSSSSFSFSSFFFSFSSFFFFSFSFSSSSSFFFSFFSFSSFFSFFSFFSSSFFFSSFSFSSFFFSFFFSSFSFSSSFFSSFSSSFFFFFSFSSFFFSFFSFSSFFSFFFSFFFSSSSSSSFSSSSSFFSFFSFFFSFFFFSSFFFSFFFSFFFFSFFSFSSSFSSSSSFFSSFFFFSSFSS...

output:

591276387

result:

ok 1 number(s): "591276387"

Test #80:

score: 0
Accepted
time: 3ms
memory: 3176kb

input:

6942
SFFFFFFSFSSSSFFSSFFFSSSSFSSSSSFFFFSSSFFSSSSFSSFSSFFSFFSSSSFSSFFFSSFSSFFFSFFFSSFFSFFSSFFSFSFSSFSFSFFSFFFSSFFFSSFFSFSFFFFFFSSSFSFFSSSSFSSFSFFSSFFSSFFFSFFFSFSFSFFSSFFSFSSSSFFFFFFFFFFFFFFFFSFSFFSFSFFSSSFSFFSFFSFFSFFFSSFFFFSFSSSSFFSSSFSSSFFSFFSSSSFSFFFFSSSSFSSFFFSSSFSSFFFFSFSFSSSFFFFFSSFSSFFFFFFFSSF...

output:

57049203

result:

ok 1 number(s): "57049203"

Test #81:

score: 0
Accepted
time: 4ms
memory: 3140kb

input:

6942
SFSFSSFSFFFFFSSFSFFSSSFFSFSFSFFSSFFSFSSFFFFSFFSSSFFSSFSFFFSSSSSFFFSSSFSFFFSFSFSFSSFFSFFSFFFFFSFSSSFSSFSFSFSSFFFSSSSSFFSFFSFSSSFFSSSSSFSFFSSFSFSFFFSSSFFFFSFFSFFSFFSFSSSSSFSFFSFFSSFFFSFSFFSFFFFSFSSFSSFFSSSFFFSSFFSFSFSFSFFFFSFSSSSSSFSSFFFFFFFFSFFFSSSSSSFFFFSSSFFSFSFFFFSFFFFFFSFSFFFFSSFSSSFFFFFFSSF...

output:

552170569

result:

ok 1 number(s): "552170569"

Test #82:

score: 0
Accepted
time: 184ms
memory: 38112kb

input:

199990
FSSFFFFFFSSFFFFFFFFSFSFSSFSSFFFFSSFFFSFFFFFFSSSFSSFFFSFFSFFFFSSSSSSFSFFFSFSSSSSSSFSSSSFSFSFFSSSSFSSSSSFSSSSFFFSFSSSSSSFSFSFSFSFSFSSFSSFSFSSFSSFSSFSSSFFSFFFSSSFSFFSSSSFFFSSSFSFFSFSSSSSFSFFFFFSFSFSFSSSSSSSSSSSFSFSFFFFSFSFSFSFSSSSFFSFSSFFSSFFFFFFFSFSSFSSFFFSFFSFFSFFFSSFFSSFFSSSSFSFFFSFFFSFSSFSFF...

output:

889655158

result:

ok 1 number(s): "889655158"

Test #83:

score: 0
Accepted
time: 157ms
memory: 37552kb

input:

199991
FFSFFSSSFSFSSFSSSFSFSFSFFFFFFFFFFSSFSFSSSSSSSFSFSFSFSSFFFSSSFSFSFFFFFFFSFSFSSFFSSFSSFSSFSSFSFFFSFFSSFSSFFSSSFFSSSFSFSFFFFSSFFSFSFSSFSFFFSFFFSFSFSSSFFFFFFSFSSSFSFFFSSFSFFSSSFFFFSSSSSFFFSSFSSFFSFFFFSSSFSFFSSSFSFFFFFFSFSSFSSSSFFSFFFFFFFSFSFSFFSSFSSSFFSSFSFSSSSSSFFSSFSSSFSSSFFSFFFFFFFSFSFFSSSFSFS...

output:

494331015

result:

ok 1 number(s): "494331015"

Test #84:

score: 0
Accepted
time: 168ms
memory: 42160kb

input:

199992
FFFSFFSSSFFSSSFFSSSFFFSFSFFSSFFFSFFFSSSFFSFSFFFFSFSFFSFSSFSSSFFSSSSFSFSSSSFFSSSSFFFSSSSFSFFSSSFSSSSFSFFSFSFFSSFSSFSSFFSFSFSFFSFFSSSSSSSSFSSSSSFFFSFSFFSFFSSSSSFSSFSFFSFSFFFFSSSFSSSSSFSSSSSSFSSSSSFFSFSSFSSFSSSSSFSFSSSSFFSFFSFFFFSSFFFFFFFFFFSSSSSFSSFFFSFFFFSFSSFSSSFSSSFFSSFSSSSSFFSSSSFFFSSFSFSSF...

output:

689624374

result:

ok 1 number(s): "689624374"

Test #85:

score: 0
Accepted
time: 173ms
memory: 41404kb

input:

199993
FFFSSSFSSFSSSFSSSSSSFFFSFSSSSSFSFFFSSFFFSFSFSFFFSSSSSFFSSSFSFSSSFSFFFFFSFSSFSFFSSFFSFSSSSSFFSFSFSSSFFFSFSSSSFFFFSSSFFSSFSFSFFSFFSFSSFFSSSFFFSSSSSSFFSFSFFFFSSFSSFFSFFSFFFSFFSFSSFFSSSSFFSSSFSFFFSFSFFFSFFSFSSFFSFFFFSSFFSFSFSFSFSSSSFSSFFSFFFFSSSFSSFFFFFFSSSSFSFSFSFFFFSSFFSSSSFSFSFSFSSSFSSFSFFSSSF...

output:

683475260

result:

ok 1 number(s): "683475260"

Test #86:

score: 0
Accepted
time: 174ms
memory: 36148kb

input:

199994
FSFSSSSSFFSFSSFFFSSFSFSFSSFFSSFSFFSSSSFSSFFFSSFFSFSSSFFFFFSSSFFFSFSSSFSFSFSFFSSFSSFSSSSSFSFFFSFFSFSFSFFSSSFFFFFSSFSSFSFFFSSFFFFFSFSSFFSFSFSSSFFFSSSSFSSFSSFSSFSFFFFFSFSSFSSFFSSSFSFSSFSSSSFSFFSFFSSFFFSSSFFSSFSFSFSFSSSSFSFFFFFFSFFSSSSSSSSFSSSFFFFFFSSSSFFFSSFSFSSSSFSSSSSSFSFSSSSFFSFFFSSSSSSFFSFSS...

output:

158196096

result:

ok 1 number(s): "158196096"

Test #87:

score: 0
Accepted
time: 193ms
memory: 37464kb

input:

199995
FSSFFFSSSFSFFSSSFSSSSSFSFSSSFSFFSSFSFSFFFSSSFSSFSFFSFFFFSSFFSSSFFSFSFFFFFFFFFFFFFSSSFSSFFFSSSFSFSSSFFFSFFSFSSSSFSFSFSFSSFFSFSFFSFFSSFSSSFSFFSSSFFSFFFSFFSFSFSFSFSSSFSSSSFFSSFFFFFSFSSSFFSSSSSSSSFFFSFSFFSSSFSFFFFFSFFFFSSSSSSSFFFSFFSFSSSFSFSFFFFSFSSFSSFFFSSFFFSSFSFFFSSSFSFSSFFSFSFFSFFSSFSFSSSSFFF...

output:

600871125

result:

ok 1 number(s): "600871125"

Test #88:

score: 0
Accepted
time: 169ms
memory: 37672kb

input:

199996
FSSFFSFSSSFFFFFFSFSSFSFFSSFFFFFFFSSSFFSFSSFSSFSFSSFSSSFFFFSFFFFFFSSSSFFFSFSSFSSFFSSFSFFSSSSSFSFFFFSFSFFSFSSFSFSSSSSFSFSSSFFSSFSSFSFFSFFSSFSFSSFSSSFSSSFFSSFFFFSFFSFSFSFFFSFSSSFFSFFSSSSSSSSFSSFSSFSSSSFSSSFSSSFSFFFFFFSFFSSSFSSFFFSFSFSFSSSFSFFSSSSFSSFSFSSFSSFSFFFSSSFFSSFSFSFFSSSFFFFSSSSSSSFSSSFFF...

output:

295471594

result:

ok 1 number(s): "295471594"

Test #89:

score: 0
Accepted
time: 205ms
memory: 37508kb

input:

199997
FFSSSFSSFSFSFSSSSFSFFSSFFFSSFFSSSSSSFSSSFFSSSFFFSFFSFSFSSSFFSSSFSFFFFFSSFFSSFFFFSSSFFFFSSSSFFFSSFFSSSFSFFSFSFSFSFFSSFSFSSSFSSFSSFSFFSSFFFSFSSFSFFSSSFSFFSFFFFSSFFSFSFFFSFSFFSFSFSFFSSFFFSSFSFFSFSSSSSFFFFFSSSSSSSSSFFFFSSFFFSSFFSFSFSSSFSFSFFSSSSFSFSFFFSSFSSFFSFFSSFSSSSSSSFSSSFSSSFSFSSSSFSFFSSSFSS...

output:

93433174

result:

ok 1 number(s): "93433174"

Test #90:

score: 0
Accepted
time: 168ms
memory: 36048kb

input:

199998
FFFSSSSSFSSSFFFFFFSSSSFSSFFFSFSSFFFSFFFFSFFFFFFFSSSFFSFSFFSFSFSFFSSFSFFSFSFSFSFFSSFFSFFFSFSFSSSSFSSSFFFSSSSFFSFFFFSFFFFFFSFSSFSFSSFFSSFSFFSFSSFSFSSFSSSSFSSFFSSFSSSSSSSSFFSFFSSSSSSSSSSSSFFSSFFFFFFSSFFSFFFFSSFFFSFFSSFFFFFFFFSFSSFSSSSFFSFSFFSSSSFSFSFFFSSFSFFFSFFSSFFSSSSSSSFSSSFFFSSFSSSSSFFFFSFSF...

output:

136831174

result:

ok 1 number(s): "136831174"

Test #91:

score: 0
Accepted
time: 177ms
memory: 36088kb

input:

199999
FSFSFSFSSFSSSFSSFFSFSFFFFFFSSFSSSFSFSSFFSSSFSSSFSSSFSFFSFSFFFFFFSFFFSFSSSSSSFFSFFSFFFFFFFSSSFFFSFFSSSFSFSSSSSFSSFSFSFFSFSFFSSFSFSSFFSFSSSSSSSSSSSFFSSSSSFSFFFSFFSFFFSFFFFFSFFFFSSSSSSSFFFFSFFSSSFSFSSFFFFSSFSFSFSSSFSSSSFSSFSFFSFFFSSFSSFFFSFSFFFSFFFFSFSFSSSSSSSFFSSFFFSSFSSSSSFSSSFFFFFSFSSSFFFSFFS...

output:

957993216

result:

ok 1 number(s): "957993216"

Test #92:

score: 0
Accepted
time: 171ms
memory: 36092kb

input:

200000
SFSSSSFSFFSFFFSFSFSSSSSSSSFFSSSFFSFFSSFFFFFFFFFFSSFFFFFFFSFFSFFFFFSSSFFFSFFSFFFFFSSFFSFFFFSSSFSFFSFSSFSFFFFFFFSFFSSFSSFSSFFSSFSSSSSFSSSSFFSFFFFFSSFSFFSFFFSSSSFFSFFFFFSSSSSSFFFSFFSFFFSFFFFFFSSSFSFFFFFSFSSSFFSSSFSFSFSSSFFFFFSSFFFSFSFFFSFSSSSSFSFFSFSSFFSSFSFFFFFSSFSFSFFFSSSFSFFFFSSSSFFFSSFFSFSFS...

output:

777222734

result:

ok 1 number(s): "777222734"

Extra Test:

score: 0
Extra Test Passed