You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: builtin.rs
    path of file: ./repos/kcl/kclvm/runtime/src/stdlib
    
    the code of the file until where you have to start completion: //! Copyright The KCL Authors. All rights reserved.

use std::{collections::HashSet, ops::Index};

use crate::*;

impl Context {
    pub fn builtin_option_init(&mut self, key: &str, value: &str) {
        if let Ok(x) = ValueRef::from_json(self, value) {
            let addr = x.into_raw(self) as u64;
            self.app_args.insert(key.to_string(), addr);
            return;
        }
        let addr = ValueRef::str(value).into_raw(self) as u64;
        self.app_args.insert(key.to_string(), addr);
    }

    pub fn builtin_option_reset(&mut self) {
        for (_, x) in self.app_args.iter() {
            if (*x) != 0 {
                // kclvm_value_delete((*x) as *mut ValueRef);
            }
        }
        self.app_args.clear();
    }
}

impl ValueRef {
    pub fn any_true(&self) -> bool {
        match &*self.rc.borrow() {
            Value::list_value(ref list) => {
                for x in list.values.iter() {
                    if x.is_truthy() {
                        return true;
                    }
                }
                false
            }
            Value::dict_value(ref dict) => {
                for (_k, x) in dict.values.iter() {
                    if x.is_truthy() {
                        return true;
                    }
                }
                false
            }
 
    
pub fn pow(x: &ValueRef, y: &ValueRef, z: &ValueRef) -> ValueRef {
    match &*z.rc.borrow() {
        Value::int_value(z) => {
            if *z == 0 {
                panic!("pow() 3rd argument cannot be 0")
            }
            match (&*x.rc.borrow(), &*y.rc.borrow()) {
                (Value::int_value(x), Value::int_value(y)) => match (*y).cmp(&0) {
                    std::cmp::Ordering::Equal => ValueRef::int(1),
                    std::cmp::Ordering::Greater => {
                        let mut ans = 1_i128;
                        let mut base = *x as i128;
                        let m = *z as i128;
                        let mut exp = *y as i128;
                        while exp > 0 {
                            if exp % 2 == 1 {
                                ans = (ans * base) % m;
                            }
                            base = (base * base) % m;
                            exp /= 2;
                        }
                        ValueRef::int(ans as i64)
                    }
                    std::cmp::Ordering::Less => {
                        panic!("pow() 2nd argument cannot be negative when 3rd argument specified")
                    }
                },
                _ => panic!("pow() 3rd argument not allowed unless all arguments are integers"),
            }
        }
        _ => match (&*x.rc.borrow(), &*y.rc.borrow()) {
            (Value::int_value(x), Value::int_value(y)) => {
                if *y >= 0 {
                    ValueRef::int((*x as f64).powf(*y as f64) as i64)
                } else {
                    ValueRef::float((*x as f64).powf(*y as f64))
                }
            }
            (Value::int_value(x), Value::float_value(y)) => ValueRef::float((*x as f64).powf(*y)),
            (Value::float_value(x), Value::int_value(y)) => ValueRef::float((*x).powf(*y as f64)),
            (Value::float_value(x), Value::float_value(y)) => ValueRef::float((*x).powf(*y)),
            _ => ValueRef::undefined(),
        },
    }
}