第4章 練習問題 - 領域展開の試練

use std::collections::VecDeque;

#[derive(Debug)]
struct Container<T> {
    items: VecDeque<T>,
    capacity: Option<usize>,
}

impl<T> Container<T> {
    fn new() -> Self {
        Container {
            items: VecDeque::new(),
            capacity: None,
        }
    }

    fn with_capacity(capacity: usize) -> Self {
        Container {
            items: VecDeque::with_capacity(capacity),
            capacity: Some(capacity),
        }
    }

    fn push(&mut self, item: T) -> Result<(), T> {
        if let Some(cap) = self.capacity {
            if self.items.len() >= cap {
                return Err(item);
            }
        }
        self.items.push_back(item);
        Ok(())
    }

    fn pop(&mut self) -> Option<T> {
        self.items.pop_back()
    }

    fn peek(&self) -> Option<&T> {
        self.items.back()
    }

    fn peek_mut(&mut self) -> Option<&mut T> {
        self.items.back_mut()
    }

    fn len(&self) -> usize {
        self.items.len()
    }

    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    fn clear(&mut self) {
        self.items.clear();
    }

    // 値の変換
    fn map<U, F>(self, f: F) -> Container<U>
    where
        F: Fn(T) -> U,
    {
        let mapped_items: VecDeque<U> = self.items.into_iter().map(f).collect();
        Container {
            items: mapped_items,
            capacity: self.capacity,
        }
    }

    // フィルタリング
    fn filter<F>(mut self, predicate: F) -> Container<T>
    where
        F: Fn(&T) -> bool,
    {
        self.items.retain(|item| predicate(item));
        self
    }

    // 安全なインデックスアクセス
    fn get(&self, index: usize) -> Option<&T> {
        self.items.get(index)
    }

    fn get_mut(&mut self, index: usize) -> Option<&mut T> {
        self.items.get_mut(index)
    }

    // イテレータ
    fn iter(&self) -> std::collections::vec_deque::Iter<T> {
        self.items.iter()
    }

    fn iter_mut(&mut self) -> std::collections::vec_deque::IterMut<T> {
        self.items.iter_mut()
    }
}

impl<T> IntoIterator for Container<T> {
    type Item = T;
    type IntoIter = std::collections::vec_deque::IntoIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        self.items.into_iter()
    }
}

// より高度な操作
impl<T> Container<T>
where
    T: Clone,
{
    fn duplicate(&self) -> Container<T> {
        Container {
            items: self.items.clone(),
            capacity: self.capacity,
        }
    }
}

impl<T> Container<T>
where
    T: PartialOrd,
{
    fn max(&self) -> Option<&T> {
        self.items.iter().max()
    }

    fn min(&self) -> Option<&T> {
        self.items.iter().min()
    }

    fn sort(&mut self) {
        let mut vec: Vec<T> = self.items.drain(..).collect();
        vec.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
        self.items = VecDeque::from(vec);
    }
}

impl<T> Container<T>
where
    T: std::fmt::Display,
{
    fn display_all(&self) {
        for (i, item) in self.items.iter().enumerate() {
            println!("{}: {}", i, item);
        }
    }
}

fn main() {
    println!("=== 汎用コンテナシステム ===");

    // 呪力値の管理
    let mut power_container = Container::with_capacity(5);

    println!("呪力値を追加:");
    for power in [1000, 1500, 800, 2000, 3000] {
        match power_container.push(power) {
            Ok(_) => println!("  {}を追加", power),
            Err(rejected) => println!("  {}は容量オーバーで拒否", rejected),
        }
    }

    println!("\\n呪力値一覧:");
    power_container.display_all();

    println!("\\n統計情報:");
    if let Some(max_power) = power_container.max() {
        println!("最大呪力: {}", max_power);
    }
    if let Some(min_power) = power_container.min() {
        println!("最小呪力: {}", min_power);
    }

    // 呪術師名の管理
    let mut name_container = Container::new();
    let names = ["五条悟", "虎杖悠仁", "伏黒恵", "釘崎野薔薇"];

    for name in names {
        name_container.push(name.to_string()).unwrap();
    }

    println!("\\n呪術師名一覧:");
    name_container.display_all();

    // 変換操作
    let formatted_names = name_container.map(|name| format!("{}先輩", name));
    println!("\\n敬称付き名前:");
    formatted_names.display_all();

    // フィルタリング
    let mut long_names = Container::new();
    for name in names {
        long_names.push(name.to_string()).unwrap();
    }

    let filtered = long_names.filter(|name| name.len() >= 4);
    println!("\\n4文字以上の名前:");
    filtered.display_all();

    // イテレータ使用
    println!("\\n呪力値の2倍計算:");
    for power in power_container.iter() {
        println!("{} -> {}", power, power * 2);
    }
}

use std::ops::{Add, Sub, Mul, Div};
use std::fmt::Display;

#[derive(Debug)]
struct Calculator<T> {
    values: Vec<T>,
}

impl<T> Calculator<T> {
    fn new() -> Self {
        Calculator {
            values: Vec::new(),
        }
    }

    fn with_values(values: Vec<T>) -> Self {
        Calculator { values }
    }

    fn add_value(&mut self, value: T) {
        self.values.push(value);
    }

    fn len(&self) -> usize {
        self.values.len()
    }

    fn is_empty(&self) -> bool {
        self.values.is_empty()
    }

    fn clear(&mut self) {
        self.values.clear();
    }
}

// 基本計算操作
impl<T> Calculator<T>
where
    T: Add<Output = T> + Copy,
{
    fn sum(&self) -> Option<T> {
        if self.values.is_empty() {
            return None;
        }

        Some(self.values[1..].iter().fold(self.values[0], |acc, &x| acc + x))
    }
}

impl<T> Calculator<T>
where
    T: Add<Output = T> + Div<Output = T> + Copy + From<usize>,
{
    fn average(&self) -> Option<T> {
        if self.values.is_empty() {
            return None;
        }

        let sum = self.sum()?;
        let count = T::from(self.values.len());
        Some(sum / count)
    }
}

impl<T> Calculator<T>
where
    T: PartialOrd + Copy,
{
    fn max(&self) -> Option<T> {
        self.values.iter().max().copied()
    }

    fn min(&self) -> Option<T> {
        self.values.iter().min().copied()
    }

    fn range(&self) -> Option<(T, T)> {
        if self.values.is_empty() {
            return None;
        }

        Some((self.min()?, self.max()?))
    }
}

// 四則演算
impl<T> Calculator<T>
where
    T: Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + Copy,
{
    fn element_wise_add(&self, other: &Calculator<T>) -> Calculator<T> {
        let results = self.values.iter()
            .zip(other.values.iter())
            .map(|(&a, &b)| a + b)
            .collect();

        Calculator { values: results }
    }

    fn element_wise_sub(&self, other: &Calculator<T>) -> Calculator<T> {
        let results = self.values.iter()
            .zip(other.values.iter())
            .map(|(&a, &b)| a - b)
            .collect();

        Calculator { values: results }
    }

    fn scalar_multiply(&self, scalar: T) -> Calculator<T> {
        let results = self.values.iter()
            .map(|&x| x * scalar)
            .collect();

        Calculator { values: results }
    }

    fn scalar_divide(&self, scalar: T) -> Calculator<T> {
        let results = self.values.iter()
            .map(|&x| x / scalar)
            .collect();

        Calculator { values: results }
    }
}

// 高度な操作
impl<T> Calculator<T>
where
    T: Copy,
{
    fn map<U, F>(&self, f: F) -> Calculator<U>
    where
        F: Fn(T) -> U,
    {
        let mapped_values = self.values.iter().map(|&x| f(x)).collect();
        Calculator { values: mapped_values }
    }

    fn filter<F>(&self, predicate: F) -> Calculator<T>
    where
        F: Fn(&T) -> bool,
    {
        let filtered_values = self.values.iter()
            .filter(|&x| predicate(x))
            .copied()
            .collect();

        Calculator { values: filtered_values }
    }

    fn reduce<F>(&self, initial: T, f: F) -> T
    where
        F: Fn(T, T) -> T,
    {
        self.values.iter().fold(initial, |acc, &x| f(acc, x))
    }
}

// 型変換
impl<T> Calculator<T> {
    fn convert<U, F>(self, converter: F) -> Calculator<U>
    where
        F: Fn(T) -> U,
    {
        let converted_values = self.values.into_iter().map(converter).collect();
        Calculator { values: converted_values }
    }
}

// 表示機能
impl<T> Calculator<T>
where
    T: Display,
{
    fn display(&self, label: &str) {
        println!("{}: [{}]", label,
                 self.values.iter()
                     .map(|x| x.to_string())
                     .collect::<Vec<_>>()
                     .join(", "));
    }

    fn display_stats(&self)
    where
        T: Add<Output = T> + Div<Output = T> + PartialOrd + Copy + From<usize>,
    {
        println!("統計情報:");
        println!("  要素数: {}", self.len());

        if let Some(sum) = self.sum() {
            println!("  合計: {}", sum);
        }

        if let Some(avg) = self.average() {
            println!("  平均: {}", avg);
        }

        if let Some(max) = self.max() {
            println!("  最大: {}", max);
        }

        if let Some(min) = self.min() {
            println!("  最小: {}", min);
        }
    }
}

// 特化した機能
impl Calculator<f64> {
    fn standard_deviation(&self) -> Option<f64> {
        if self.values.len() < 2 {
            return None;
        }

        let avg = self.average()?;
        let variance = self.values.iter()
            .map(|&x| (x - avg).powi(2))
            .sum::<f64>() / (self.values.len() - 1) as f64;

        Some(variance.sqrt())
    }

    fn median(&self) -> Option<f64> {
        if self.values.is_empty() {
            return None;
        }

        let mut sorted = self.values.clone();
        sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());

        let mid = sorted.len() / 2;

        if sorted.len() % 2 == 0 {
            Some((sorted[mid - 1] + sorted[mid]) / 2.0)
        } else {
            Some(sorted[mid])
        }
    }
}

fn main() {
    println!("=== ジェネリック計算システム ===");

    // 整数での計算
    let mut int_calc = Calculator::new();
    let powers = [1000, 1500, 800, 2000, 1200];

    for power in powers {
        int_calc.add_value(power);
    }

    int_calc.display("呪力値");
    int_calc.display_stats();

    println!();

    // 浮動小数点での計算
    let float_calc = Calculator::with_values(vec![1000.0, 1500.5, 800.3, 2000.7, 1200.1]);
    float_calc.display("精密呪力値");
    float_calc.display_stats();

    if let Some(std_dev) = float_calc.standard_deviation() {
        println!("  標準偏差: {:.2}", std_dev);
    }

    if let Some(median) = float_calc.median() {
        println!("  中央値: {:.2}", median);
    }

    println!();

    // 計算操作
    let calc1 = Calculator::with_values(vec![100, 200, 300]);
    let calc2 = Calculator::with_values(vec![50, 100, 150]);

    calc1.display("計算1");
    calc2.display("計算2");

    let sum_result = calc1.element_wise_add(&calc2);
    sum_result.display("要素ごとの和");

    let diff_result = calc1.element_wise_sub(&calc2);
    diff_result.display("要素ごとの差");

    let scaled = calc1.scalar_multiply(2);
    scaled.display("2倍");

    println!();

    // 変換操作
    let power_calc = Calculator::with_values(vec![1000, 1500, 2000]);
    power_calc.display("元の呪力");

    // 整数から文字列への変換
    let string_calc = power_calc.convert(|x| {
        match x {
            x if x >= 2000 => format!("{}（特級）", x),
            x if x >= 1500 => format!("{}（1級）", x),
            x if x >= 1000 => format!("{}（2級）", x),
            x => format!("{}（下級）", x),
        }
    });

    string_calc.display("等級付き呪力");

    // フィルタリング
    let high_powers = Calculator::with_values(vec![500, 1000, 1500, 2000, 3000]);
    high_powers.display("全呪力値");

    let filtered = high_powers.filter(|&x| x >= 1500);
    filtered.display("1500以上の呪力");

    // カスタム計算
    let doubled = high_powers.map(|x| x * 2);
    doubled.display("2倍した呪力");

    let power_sum = high_powers.reduce(0, |acc, x| acc + x);
    println!("\\nカスタム合計計算: {}", power_sum);
}

use std::collections::HashMap;
use std::fmt;

// 基本的な存在情報
trait Entity {
    fn name(&self) -> &str;
    fn entity_type(&self) -> &str;
    fn level(&self) -> u32;
    fn is_alive(&self) -> bool;
}

// 戦闘能力
trait Combatant: Entity {
    fn max_health(&self) -> i32;
    fn current_health(&self) -> i32;
    fn attack_power(&self) -> i32;
    fn defense_power(&self) -> i32;

    fn take_damage(&mut self, damage: i32) -> i32;
    fn calculate_damage(&self, target: &dyn Combatant) -> i32 {
        let base_damage = self.attack_power();
        let defense = target.defense_power();
        (base_damage - defense / 2).max(1)
    }
}

// 術式使用能力
trait TechniqueUser: Entity {
    fn available_techniques(&self) -> &[String];
    fn mana(&self) -> i32;
    fn max_mana(&self) -> i32;

    fn use_technique(&mut self, technique_name: &str, target: &mut dyn Combatant) -> Result<String, String>;
    fn recover_mana(&mut self, amount: i32);
}

// 回復能力
trait Healable: Combatant {
    fn heal(&mut self, amount: i32) -> i32;
    fn can_heal(&self) -> bool {
        self.current_health() < self.max_health()
    }
}

// 表示機能
trait Displayable {
    fn display_status(&self) -> String;
    fn display_summary(&self) -> String;
}

// 呪術師実装
#[derive(Debug, Clone)]
struct Sorcerer {
    name: String,
    level: u32,
    max_health: i32,
    current_health: i32,
    attack_power: i32,
    defense_power: i32,
    max_mana: i32,
    current_mana: i32,
    techniques: Vec<String>,
    technique_costs: HashMap<String, i32>,
}

impl Sorcerer {
    fn new(name: &str, level: u32, health: i32, attack: i32, defense: i32, mana: i32) -> Self {
        let mut sorcerer = Sorcerer {
            name: name.to_string(),
            level,
            max_health: health,
            current_health: health,
            attack_power: attack,
            defense_power: defense,
            max_mana: mana,
            current_mana: mana,
            techniques: Vec::new(),
            technique_costs: HashMap::new(),
        };

        // デフォルト術式
        sorcerer.learn_technique("基本攻撃", 10);
        sorcerer.learn_technique("強化攻撃", 25);

        sorcerer
    }

    fn learn_technique(&mut self, name: &str, cost: i32) {
        self.techniques.push(name.to_string());
        self.technique_costs.insert(name.to_string(), cost);
    }
}

impl Entity for Sorcerer {
    fn name(&self) -> &str {
        &self.name
    }

    fn entity_type(&self) -> &str {
        "呪術師"
    }

    fn level(&self) -> u32 {
        self.level
    }

    fn is_alive(&self) -> bool {
        self.current_health > 0
    }
}

impl Combatant for Sorcerer {
    fn max_health(&self) -> i32 {
        self.max_health
    }

    fn current_health(&self) -> i32 {
        self.current_health
    }

    fn attack_power(&self) -> i32 {
        self.attack_power
    }

    fn defense_power(&self) -> i32 {
        self.defense_power
    }

    fn take_damage(&mut self, damage: i32) -> i32 {
        let actual_damage = damage.min(self.current_health);
        self.current_health -= actual_damage;
        actual_damage
    }
}

impl TechniqueUser for Sorcerer {
    fn available_techniques(&self) -> &[String] {
        &self.techniques
    }

    fn mana(&self) -> i32 {
        self.current_mana
    }

    fn max_mana(&self) -> i32 {
        self.max_mana
    }

    fn use_technique(&mut self, technique_name: &str, target: &mut dyn Combatant) -> Result<String, String> {
        let cost = self.technique_costs.get(technique_name)
            .ok_or_else(|| format!("{}は{}を知りません", self.name, technique_name))?;

        if self.current_mana < *cost {
            return Err(format!("{}のマナが不足しています（必要: {}, 現在: {}）",
                             self.name, cost, self.current_mana));
        }

        self.current_mana -= cost;

        let damage = match technique_name {
            "基本攻撃" => self.calculate_damage(target),
            "強化攻撃" => self.calculate_damage(target) * 2,
            "回復術" => {
                if let Some(healable_target) = (target as &mut dyn std::any::Any).downcast_mut::<Sorcerer>() {
                    let heal_amount = self.attack_power() / 2;
                    healable_target.heal(heal_amount);
                    return Ok(format!("{}が{}を{}回復させた", self.name, target.name(), heal_amount));
                } else {
                    return Err("回復対象が無効です".to_string());
                }
            },
            _ => self.calculate_damage(target),
        };

        let actual_damage = target.take_damage(damage);
        Ok(format!("{}が{}で{}に{}ダメージ",
                  self.name, technique_name, target.name(), actual_damage))
    }

    fn recover_mana(&mut self, amount: i32) {
        self.current_mana = (self.current_mana + amount).min(self.max_mana);
    }
}

impl Healable for Sorcerer {
    fn heal(&mut self, amount: i32) -> i32 {
        let actual_heal = amount.min(self.max_health - self.current_health);
        self.current_health += actual_heal;
        actual_heal
    }
}

impl Displayable for Sorcerer {
    fn display_status(&self) -> String {
        format!(
            "=== {} ===\\nレベル: {}\\nHP: {}/{}\\nマナ: {}/{}\\n攻撃力: {}\\n防御力: {}\\n習得術式: {:?}\\n状態: {}",
            self.name,
            self.level,
            self.current_health, self.max_health,
            self.current_mana, self.max_mana,
            self.attack_power,
            self.defense_power,
            self.techniques,
            if self.is_alive() { "生存" } else { "戦闘不能" }
        )
    }

    fn display_summary(&self) -> String {
        format!("{} (Lv.{}, HP: {}/{}, マナ: {}/{})",
                self.name, self.level,
                self.current_health, self.max_health,
                self.current_mana, self.max_mana)
    }
}

impl fmt::Display for Sorcerer {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.display_summary())
    }
}

// 呪霊実装
#[derive(Debug, Clone)]
struct Curse {
    name: String,
    grade: String,
    level: u32,
    max_health: i32,
    current_health: i32,
    attack_power: i32,
    defense_power: i32,
}

impl Curse {
    fn new(name: &str, grade: &str, level: u32, health: i32, attack: i32, defense: i32) -> Self {
        Curse {
            name: name.to_string(),
            grade: grade.to_string(),
            level,
            max_health: health,
            current_health: health,
            attack_power: attack,
            defense_power: defense,
        }
    }
}

impl Entity for Curse {
    fn name(&self) -> &str {
        &self.name
    }

    fn entity_type(&self) -> &str {
        "呪霊"
    }

    fn level(&self) -> u32 {
        self.level
    }

    fn is_alive(&self) -> bool {
        self.current_health > 0
    }
}

impl Combatant for Curse {
    fn max_health(&self) -> i32 {
        self.max_health
    }

    fn current_health(&self) -> i32 {
        self.current_health
    }

    fn attack_power(&self) -> i32 {
        self.attack_power
    }

    fn defense_power(&self) -> i32 {
        self.defense_power
    }

    fn take_damage(&mut self, damage: i32) -> i32 {
        let actual_damage = damage.min(self.current_health);
        self.current_health -= actual_damage;
        actual_damage
    }
}

impl Displayable for Curse {
    fn display_status(&self) -> String {
        format!(
            "=== {} ===\\n等級: {}\\nレベル: {}\\nHP: {}/{}\\n攻撃力: {}\\n防御力: {}\\n状態: {}",
            self.name,
            self.grade,
            self.level,
            self.current_health, self.max_health,
            self.attack_power,
            self.defense_power,
            if self.is_alive() { "生存" } else { "祓われた" }
        )
    }

    fn display_summary(&self) -> String {
        format!("{} ({}級, Lv.{}, HP: {}/{})",
                self.name, self.grade, self.level,
                self.current_health, self.max_health)
    }
}

impl fmt::Display for Curse {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.display_summary())
    }
}

// 戦闘システム
struct BattleSystem;

impl BattleSystem {
    fn one_vs_one(
        fighter1: &mut dyn Combatant,
        fighter2: &mut dyn Combatant
    ) -> String {
        let mut log = String::new();
        let mut round = 1;

        log.push_str(&format!("=== 1対1戦闘: {} vs {} ===\\n",
                             fighter1.name(), fighter2.name()));

        while fighter1.is_alive() && fighter2.is_alive() && round <= 10 {
            log.push_str(&format!("\\n--- ラウンド {} ---\\n", round));

            // ファイター1の攻撃
            if fighter1.is_alive() {
                let damage = fighter1.calculate_damage(fighter2);
                let actual_damage = fighter2.take_damage(damage);
                log.push_str(&format!("{}が{}を攻撃！{}ダメージ\\n",
                                     fighter1.name(), fighter2.name(), actual_damage));

                if !fighter2.is_alive() {
                    log.push_str(&format!("{}が倒れた！\\n", fighter2.name()));
                    break;
                }
            }

            // ファイター2の攻撃
            if fighter2.is_alive() {
                let damage = fighter2.calculate_damage(fighter1);
                let actual_damage = fighter1.take_damage(damage);
                log.push_str(&format!("{}が{}を攻撃！{}ダメージ\\n",
                                     fighter2.name(), fighter1.name(), actual_damage));

                if !fighter1.is_alive() {
                    log.push_str(&format!("{}が倒れた！\\n", fighter1.name()));
                    break;
                }
            }

            round += 1;
        }

        // 勝者の発表
        if fighter1.is_alive() && !fighter2.is_alive() {
            log.push_str(&format!("\\n勝者: {}！\\n", fighter1.name()));
        } else if fighter2.is_alive() && !fighter1.is_alive() {
            log.push_str(&format!("\\n勝者: {}！\\n", fighter2.name()));
        } else if round > 10 {
            log.push_str("\\n時間切れで引き分け！\\n");
        } else {
            log.push_str("\\n両者戦闘不能...\\n");
        }

        log
    }

    fn technique_battle<T1, T2>(
        user: &mut T1,
        target: &mut T2,
        technique: &str
    ) -> String
    where
        T1: TechniqueUser + Combatant,
        T2: Combatant,
    {
        match user.use_technique(technique, target) {
            Ok(result) => result,
            Err(error) => error,
        }
    }
}

fn main() {
    println!("=== 呪術戦闘システム ===");

    // キャラクター作成
    let mut gojo = Sorcerer::new("五条悟", 10, 2000, 300, 200, 500);
    gojo.learn_technique("無下限術式", 50);
    gojo.learn_technique("領域展開", 200);

    let mut yuji = Sorcerer::new("虎杖悠仁", 5, 1500, 250, 150, 300);
    yuji.learn_technique("黒閃", 40);

    let mut special_curse = Curse::new("特級呪霊", "特級", 8, 1800, 280, 180);

    // ステータス表示
    println!("{}", gojo.display_status());
    println!();
    println!("{}", yuji.display_status());
    println!();
    println!("{}", special_curse.display_status());
    println!();

    // 術式戦闘
    println!("=== 術式使用テスト ===");
    let result = BattleSystem::technique_battle(&mut gojo, &mut special_curse, "無下限術式");
    println!("{}", result);

    let result = BattleSystem::technique_battle(&mut yuji, &mut gojo, "黒閃");
    println!("{}", result);

    // マナ不足のテスト
    let result = BattleSystem::technique_battle(&mut gojo, &mut special_curse, "領域展開");
    println!("{}", result);

    println!();

    // 1対1戦闘
    let mut gojo_clone = gojo.clone();
    let mut curse_clone = special_curse.clone();

    let battle_log = BattleSystem::one_vs_one(&mut gojo_clone, &mut curse_clone);
    println!("{}", battle_log);

    // 戦闘後ステータス
    println!("=== 戦闘後ステータス ===");
    println!("{}", gojo_clone.display_summary());
    println!("{}", curse_clone.display_summary());

    // 回復テスト
    if gojo_clone.can_heal() {
        let healed = gojo_clone.heal(200);
        println!("\\n{}が{}回復した", gojo_clone.name(), healed);
        println!("{}", gojo_clone.display_summary());
    }

    // マナ回復
    gojo_clone.recover_mana(100);
    println!("マナ回復後: {}", gojo_clone.display_summary());
}