Submission #64189632

---

Source Code Expand

// Generated by Shol compiler.
// DO NOT EDIT MANUALLY.
//
// Original source: example/paren.shol
// Shol version: 1.0.0

#![allow(
  non_snake_case,
  non_camel_case_types,
  dead_code,
  unused_variables,
  unused_imports,
  unused_mut,
  unreachable_patterns,
  unused_parens,
  unused_assignments,
)]
use std::{collections::HashMap,fmt,io::{self, BufRead, Write},process::ExitCode,sync::mpsc,thread,time::Duration};

static SYMBOLS: [&str; 0] = [];
#[derive(PartialEq,Clone)]
enum ResourceType {
  String(String),
  Symbol(usize),
  Bool(bool),
  Double(f64),
  Int(i32),
}
impl fmt::Debug for ResourceType {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    match self {
      ResourceType::Symbol(v) => write!(f, "'{}", SYMBOLS[*v]),
      ResourceType::Bool(v) => write!(f, "{v:?}"),
      ResourceType::Double(v) => write!(f, "{v:?}"),
      ResourceType::Int(v) => write!(f, "{v:?}"),
      ResourceType::String(v) => write!(f, "{v:?}"),
    }
  }
}
impl fmt::Display for ResourceType {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    match self {
      ResourceType::Symbol(v) => write!(f, "{}", SYMBOLS[*v]),
      ResourceType::Bool(v) => write!(f, "{v}"),
      ResourceType::Double(v) => write!(f, "{v}"),
      ResourceType::Int(v) => write!(f, "{v}"),
      ResourceType::String(v) => write!(f, "{v}"),
    }
  }
}
fn chr(a:i32)->String{char::from_u32(a as u32).map(String::from).unwrap_or_default()}
fn ord(a:String)->i32{a.chars().next().unwrap_or('\0')as i32}
fn nth(s:String,n:i32)->String{s.chars().nth(n as usize).map_or_else(String::new,String::from)}
fn slice(s:&str,start:Option<i32>,end:Option<i32>,step:Option<i32>)->String{
  let s: Vec<char> = s.chars().collect();
  let len = s.len() as i32;

  let step = step.unwrap_or(1);
  if step == 0 { return String::new(); }

  let start = match start {
    Some(start)=>if start<0{ (start+len).max(0) }else{ start.clamp(0,len-1) },
    None=>if step>0{ 0 }else{ len-1 }
  };
  let end = match end {
    Some(end)=>if end<0{ (end+len).max(0) }else{ end.clamp(0,len) },
    None=>if step>0{ len }else{ -1 }
  };

  let mut r = String::new();
  if step > 0 {
    let mut i = start;
    while i < end {
      r.push(s[i as usize]);
      i += step;
    }
  } else {
    let mut i = start;
    while i > end {
      r.push(s[i as usize]);
      i += step;
    }
  }
  r
}
trait Colony {
  fn receive(&mut self, g: Vec<ResourceType>);
  fn rule(&mut self) -> Result<HashMap<usize, Vec<ResourceType>>, ExitCode>;
}

struct Colony_cin {
  resources: Vec<ResourceType>,
}
impl Colony for Colony_cin {
  fn receive(&mut self, g: Vec<ResourceType>) { self.resources.extend(g); }
  fn rule(&mut self) -> Result<HashMap<usize, Vec<ResourceType>>, ExitCode> {
    let mut gifts: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    let mut buf = Vec::new();
    for (i, resource) in self.resources.iter().enumerate() {
      let mut no_match = true;
      match resource {
        ResourceType::Double(v) => {
          {
            buf.push(ResourceType::Int((v.clone() as i32)));
            no_match = false;
          }
        }
        ResourceType::String(v) => {
          {
            buf.push(ResourceType::Int((v.clone().parse::<i32>().unwrap_or_default())));
            no_match = false;
          }
        }
        ResourceType::Int(v) => {
        }
        ResourceType::Bool(v) => {
          {
            buf.push(ResourceType::Int((v.clone() as i32)));
            no_match = false;
          }
        }
        ResourceType::Symbol(v) => {
        }
      }
      if no_match {
        buf.push(resource.clone());
      }
    }
    self.resources = buf;
    let mut buf = Vec::new();
    for (i, resource) in self.resources.iter().enumerate() {
      let mut no_match = true;
      match resource {
        ResourceType::Bool(v) => {
          {
            let entry = gifts.entry(1).or_default();
            entry.push(ResourceType::String("".to_owned()));
            entry.push(ResourceType::Bool(v.clone()));
            entry.push(ResourceType::Int((0i32)));
            no_match = false;
          }
          {
            let entry = gifts.entry(3).or_default();
            entry.push(ResourceType::Bool(v.clone()));
            no_match = false;
          }
        }
        ResourceType::Int(v) => {
          {
            let entry = gifts.entry(1).or_default();
            entry.push(ResourceType::String("".to_owned()));
            entry.push(ResourceType::Int(v.clone()));
            entry.push(ResourceType::Int((0i32)));
            no_match = false;
          }
          {
            let entry = gifts.entry(3).or_default();
            entry.push(ResourceType::Int(v.clone()));
            no_match = false;
          }
        }
        ResourceType::Symbol(v) => {
          {
            let entry = gifts.entry(1).or_default();
            entry.push(ResourceType::String("".to_owned()));
            entry.push(ResourceType::Symbol(v.clone()));
            entry.push(ResourceType::Int((0i32)));
            no_match = false;
          }
          {
            let entry = gifts.entry(3).or_default();
            entry.push(ResourceType::Symbol(v.clone()));
            no_match = false;
          }
        }
        ResourceType::Double(v) => {
          {
            let entry = gifts.entry(1).or_default();
            entry.push(ResourceType::String("".to_owned()));
            entry.push(ResourceType::Double(v.clone()));
            entry.push(ResourceType::Int((0i32)));
            no_match = false;
          }
          {
            let entry = gifts.entry(3).or_default();
            entry.push(ResourceType::Double(v.clone()));
            no_match = false;
          }
        }
        ResourceType::String(v) => {
          {
            let entry = gifts.entry(1).or_default();
            entry.push(ResourceType::String("".to_owned()));
            entry.push(ResourceType::String(v.clone()));
            entry.push(ResourceType::Int((0i32)));
            no_match = false;
          }
          {
            let entry = gifts.entry(3).or_default();
            entry.push(ResourceType::String(v.clone()));
            no_match = false;
          }
        }
      }
      if no_match {
        buf.push(resource.clone());
      }
    }
    self.resources = buf;
    Ok(gifts)
  }
}

struct Colony_paren {
  resources: Vec<ResourceType>,
}
impl Colony for Colony_paren {
  fn receive(&mut self, g: Vec<ResourceType>) { self.resources.extend(g); }
  fn rule(&mut self) -> Result<HashMap<usize, Vec<ResourceType>>, ExitCode> {
    let mut gifts: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    let mut insertions: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    let mut some_used: Vec<bool> = vec![false; self.resources.len()];
    let mut used: Vec<bool> = vec![false; self.resources.len()];
    let mut capt_prog: Vec<usize> = vec![0;3];
    let mut capt_idx: usize = 0;
    while capt_prog[capt_idx] < self.resources.len() {
      if used[capt_prog[capt_idx]] {
        capt_prog[capt_idx] += 1;
        continue;
      }
      match capt_idx {
        0 => {
          if match &self.resources[capt_prog[0]] {
            ResourceType::String(_) => true,
            _ => false
          } {
            capt_idx = 1;
            used[capt_prog[0]] = true;
            capt_prog[0] += 1;
            capt_prog[1] = capt_prog[0];
          } else {
            capt_prog[0] += 1;
          }
        },
        1 => {
          if capt_prog[1]==capt_prog[0] && match &self.resources[capt_prog[1]] {
            ResourceType::Int(_)|ResourceType::Double(_) => true,
            _ => false
          } {
            capt_idx = 2;
            used[capt_prog[1]] = true;
            capt_prog[1] += 1;
            capt_prog[2] = capt_prog[1];
          } else {
            capt_idx = 0;
            for i in 0..1 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[1] += 1;
          }
        },
        2 => {
          if capt_prog[2]==capt_prog[1] && match &self.resources[capt_prog[2]] {
            ResourceType::String(_)|ResourceType::Int(_)|ResourceType::Double(_) => true,
            _ => false
          } {
            capt_idx = 0;
            used[capt_prog[2]] = true;
            capt_prog[2] += 1;
            let entry = insertions.entry(capt_prog[0]-1).or_default();
            match (&self.resources[capt_prog[0]-1],) {
              (ResourceType::String(v_),) =>
                entry.push(ResourceType::String((format!("{}{}",v_.clone(),"(".to_owned())))),
              _ => ()
            }
            match (&self.resources[capt_prog[1]-1],) {
              (ResourceType::Int(v_l),) =>
                entry.push(ResourceType::Int((v_l.clone()-(1i32)))),
              (ResourceType::Double(v_l),) =>
                entry.push(ResourceType::Double((v_l.clone()-((1i32) as f64)))),
              _ => ()
            }
            match (&self.resources[capt_prog[2]-1],) {
              (ResourceType::String(v_n),) =>
                entry.push(ResourceType::String((format!("{}{}",v_n.clone(),(1i32))))),
              (ResourceType::Int(v_n),) =>
                entry.push(ResourceType::Int((v_n.clone()+(1i32)))),
              (ResourceType::Double(v_n),) =>
                entry.push(ResourceType::Double((v_n.clone()+((1i32) as f64)))),
              _ => ()
            }
          } else {
            capt_idx = 0;
            for i in 0..2 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[2] += 1;
          }
        },
        _ => unreachable!()
      }
    }
    for i in 0..capt_idx {
      used[capt_prog[i]-1] = false;
    }
    for i in 0..self.resources.len() {
      some_used[i] |= used[i];
    }
    let mut used: Vec<bool> = vec![false; self.resources.len()];
    let mut capt_prog: Vec<usize> = vec![0;3];
    let mut capt_idx: usize = 0;
    while capt_prog[capt_idx] < self.resources.len() {
      if used[capt_prog[capt_idx]] {
        capt_prog[capt_idx] += 1;
        continue;
      }
      match capt_idx {
        0 => {
          if match &self.resources[capt_prog[0]] {
            ResourceType::String(_) => true,
            _ => false
          } {
            capt_idx = 1;
            used[capt_prog[0]] = true;
            capt_prog[0] += 1;
            capt_prog[1] = capt_prog[0];
          } else {
            capt_prog[0] += 1;
          }
        },
        1 => {
          if capt_prog[1]==capt_prog[0] && match &self.resources[capt_prog[1]] {
            ResourceType::Int(_)|ResourceType::Double(_) => true,
            _ => false
          } {
            capt_idx = 2;
            used[capt_prog[1]] = true;
            capt_prog[1] += 1;
            capt_prog[2] = capt_prog[1];
          } else {
            capt_idx = 0;
            for i in 0..1 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[1] += 1;
          }
        },
        2 => {
          if capt_prog[2]==capt_prog[1] && match &self.resources[capt_prog[2]] {
            ResourceType::Int(v) => (v.clone()>(0i32)),
            ResourceType::Double(v) => (v.clone()>((0i32) as f64)),
            _ => false
          } {
            capt_idx = 0;
            used[capt_prog[2]] = true;
            capt_prog[2] += 1;
            let entry = insertions.entry(capt_prog[0]-1).or_default();
            match (&self.resources[capt_prog[0]-1],) {
              (ResourceType::String(v_),) =>
                entry.push(ResourceType::String((format!("{}{}",v_.clone(),")".to_owned())))),
              _ => ()
            }
            match (&self.resources[capt_prog[1]-1],) {
              (ResourceType::Int(v_l),) =>
                entry.push(ResourceType::Int((v_l.clone()-(1i32)))),
              (ResourceType::Double(v_l),) =>
                entry.push(ResourceType::Double((v_l.clone()-((1i32) as f64)))),
              _ => ()
            }
            match (&self.resources[capt_prog[2]-1],) {
              (ResourceType::Int(v_n),) =>
                entry.push(ResourceType::Int((v_n.clone()-(1i32)))),
              (ResourceType::Double(v_n),) =>
                entry.push(ResourceType::Double((v_n.clone()-((1i32) as f64)))),
              _ => ()
            }
          } else {
            capt_idx = 0;
            for i in 0..2 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[2] += 1;
          }
        },
        _ => unreachable!()
      }
    }
    for i in 0..capt_idx {
      used[capt_prog[i]-1] = false;
    }
    for i in 0..self.resources.len() {
      some_used[i] |= used[i];
    }
    let mut buf = Vec::new();
    for (i, resource) in self.resources.iter().enumerate() {
      let mut no_match = true;
      no_match &= !some_used[i];
      if let Some(insertion) = insertions.get(&i) {
        buf.extend(insertion.clone());
      }
      if no_match {
        buf.push(resource.clone());
      }
    }
    self.resources = buf;
    let mut insertions: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    let mut some_used: Vec<bool> = vec![false; self.resources.len()];
    let mut used: Vec<bool> = vec![false; self.resources.len()];
    let mut capt_prog: Vec<usize> = vec![0;3];
    let mut capt_idx: usize = 0;
    while capt_prog[capt_idx] < self.resources.len() {
      if used[capt_prog[capt_idx]] {
        capt_prog[capt_idx] += 1;
        continue;
      }
      match capt_idx {
        0 => {
          if match &self.resources[capt_prog[0]] {
            ResourceType::Double(_)|ResourceType::Symbol(_)|ResourceType::String(_)|ResourceType::Int(_)|ResourceType::Bool(_) => true,
            _ => false
          } {
            capt_idx = 1;
            used[capt_prog[0]] = true;
            capt_prog[0] += 1;
            capt_prog[1] = capt_prog[0];
          } else {
            capt_prog[0] += 1;
          }
        },
        1 => {
          if capt_prog[1]==capt_prog[0] && match &self.resources[capt_prog[1]] {
            ResourceType::Int(v) => v.clone() == (0i32),
            _ => false
          } {
            capt_idx = 2;
            used[capt_prog[1]] = true;
            capt_prog[1] += 1;
            capt_prog[2] = capt_prog[1];
          } else {
            capt_idx = 0;
            for i in 0..1 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[1] += 1;
          }
        },
        2 => {
          if capt_prog[2]==capt_prog[1] && match &self.resources[capt_prog[2]] {
            ResourceType::Int(v) => v.clone() == (0i32),
            _ => false
          } {
            capt_idx = 0;
            used[capt_prog[2]] = true;
            capt_prog[2] += 1;
            let entry = gifts.entry(2).or_default();
            match (&self.resources[capt_prog[0]-1],) {
              (ResourceType::Double(v_),) =>
                entry.push(ResourceType::Double(v_.clone())),
              (ResourceType::Symbol(v_),) =>
                entry.push(ResourceType::Symbol(v_.clone())),
              (ResourceType::String(v_),) =>
                entry.push(ResourceType::String(v_.clone())),
              (ResourceType::Int(v_),) =>
                entry.push(ResourceType::Int(v_.clone())),
              (ResourceType::Bool(v_),) =>
                entry.push(ResourceType::Bool(v_.clone())),
              _ => ()
            }
          } else {
            capt_idx = 0;
            for i in 0..2 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[2] += 1;
          }
        },
        _ => unreachable!()
      }
    }
    for i in 0..capt_idx {
      used[capt_prog[i]-1] = false;
    }
    for i in 0..self.resources.len() {
      some_used[i] |= used[i];
    }
    let mut buf = Vec::new();
    for (i, resource) in self.resources.iter().enumerate() {
      let mut no_match = true;
      no_match &= !some_used[i];
      if let Some(insertion) = insertions.get(&i) {
        buf.extend(insertion.clone());
      }
      if no_match {
        buf.push(resource.clone());
      }
    }
    self.resources = buf;
    let mut insertions: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    let mut some_used: Vec<bool> = vec![false; self.resources.len()];
    let mut used: Vec<bool> = vec![false; self.resources.len()];
    let mut capt_prog: Vec<usize> = vec![0;3];
    let mut capt_idx: usize = 0;
    while capt_prog[capt_idx] < self.resources.len() {
      if used[capt_prog[capt_idx]] {
        capt_prog[capt_idx] += 1;
        continue;
      }
      match capt_idx {
        0 => {
          if match &self.resources[capt_prog[0]] {
            ResourceType::String(_) => true,
            _ => false
          } {
            capt_idx = 1;
            used[capt_prog[0]] = true;
            capt_prog[0] += 1;
            capt_prog[1] = capt_prog[0];
          } else {
            capt_prog[0] += 1;
          }
        },
        1 => {
          if capt_prog[1]==capt_prog[0] && match &self.resources[capt_prog[1]] {
            ResourceType::Int(v) => v.clone() == (0i32),
            _ => false
          } {
            capt_idx = 2;
            used[capt_prog[1]] = true;
            capt_prog[1] += 1;
            capt_prog[2] = capt_prog[1];
          } else {
            capt_idx = 0;
            for i in 0..1 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[1] += 1;
          }
        },
        2 => {
          if capt_prog[2]==capt_prog[1] && match &self.resources[capt_prog[2]] {
            ResourceType::Double(_)|ResourceType::Symbol(_)|ResourceType::Int(_)|ResourceType::String(_)|ResourceType::Bool(_) => true,
            _ => false
          } {
            capt_idx = 0;
            used[capt_prog[2]] = true;
            capt_prog[2] += 1;
          } else {
            capt_idx = 0;
            for i in 0..2 {
              used[capt_prog[i]-1] = false;
            }
            capt_prog[2] += 1;
          }
        },
        _ => unreachable!()
      }
    }
    for i in 0..capt_idx {
      used[capt_prog[i]-1] = false;
    }
    for i in 0..self.resources.len() {
      some_used[i] |= used[i];
    }
    let mut buf = Vec::new();
    for (i, resource) in self.resources.iter().enumerate() {
      let mut no_match = true;
      no_match &= !some_used[i];
      if let Some(insertion) = insertions.get(&i) {
        buf.extend(insertion.clone());
      }
      if no_match {
        buf.push(resource.clone());
      }
    }
    self.resources = buf;
    Ok(gifts)
  }
}

struct Colony_print {
  resources: Vec<ResourceType>,
}
impl Colony for Colony_print {
  fn receive(&mut self, g: Vec<ResourceType>) { self.resources.extend(g); }
  fn rule(&mut self) -> Result<HashMap<usize, Vec<ResourceType>>, ExitCode> {
    let mut gifts: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    for resource in &self.resources {
      println!("{resource}");
    }
    self.resources = vec![];
    Ok(gifts)
  }
}

struct Colony_exit_counter {
  resources: Vec<ResourceType>,
}
impl Colony for Colony_exit_counter {
  fn receive(&mut self, g: Vec<ResourceType>) { self.resources.extend(g); }
  fn rule(&mut self) -> Result<HashMap<usize, Vec<ResourceType>>, ExitCode> {
    let mut gifts: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    let mut buf = Vec::new();
    for (i, resource) in self.resources.iter().enumerate() {
      let mut no_match = true;
      match resource {
        ResourceType::Bool(v) => {
        }
        ResourceType::Symbol(v) => {
        }
        ResourceType::Int(v) => {
          {
            buf.push(ResourceType::Int((v.clone()-(1i32))));
            no_match = false;
          }
          if v.clone() == (0i32) {
            let entry = gifts.entry(4).or_default();
            entry.push(ResourceType::Int((0i32)));
            no_match = false;
          }
        }
        ResourceType::Double(v) => {
          {
            buf.push(ResourceType::Double((v.clone()-((1i32) as f64))));
            no_match = false;
          }
        }
        ResourceType::String(v) => {
        }
      }
      if no_match {
        buf.push(resource.clone());
      }
    }
    self.resources = buf;
    Ok(gifts)
  }
}

struct Colony_exit {
  resources: Vec<ResourceType>,
}
impl Colony for Colony_exit {
  fn receive(&mut self, g: Vec<ResourceType>) { self.resources.extend(g); }
  fn rule(&mut self) -> Result<HashMap<usize, Vec<ResourceType>>, ExitCode> {
    let mut gifts: HashMap<usize, Vec<ResourceType>> = HashMap::new();
    let mut buf = Vec::new();
    for resource in &self.resources {
      let mut no_match = true;
      match resource {
        ResourceType::Int(v) => return Err(ExitCode::from(*v as u8)),
        ResourceType::String(_)|ResourceType::Bool(_)|ResourceType::Double(_)|ResourceType::Symbol(_) => {}
      }
      if no_match {
        buf.push(resource.clone());
      }
    }
    self.resources = buf;
    Ok(gifts)
  }
}

fn main() -> ExitCode{
  let mut colonies: Vec<Box<dyn Colony>> = Vec::new();
  colonies.push(Box::new(Colony_cin {
    resources: vec![
    ],
  }));
  colonies.push(Box::new(Colony_paren {
    resources: vec![
    ],
  }));
  colonies.push(Box::new(Colony_print {
    resources: vec![
    ],
  }));
  colonies.push(Box::new(Colony_exit_counter {
    resources: vec![
    ],
  }));
  colonies.push(Box::new(Colony_exit {
    resources: vec![
    ],
  }));
  let (tx, rx) = mpsc::channel();
  thread::spawn(move || {
    for l in io::stdin().lock().lines() {
      if let Ok(l) = l {
        if tx.send(l).is_err() { break; }
      }
    }
  });
  loop {
    for i in 0..colonies.len() {
      if let Ok(l) = rx.try_recv() {
        colonies[0].receive(vec![ResourceType::String(l)]);
      }
      match colonies[i].rule() {
        Ok(gifts) =>
          for (d, gv) in gifts {
            colonies[d].receive(gv);
          }
        Err(c) => return c
      }
    }
  }
}

Submission Info

Judge Result