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: val_cmp.rs
    path of file: ./repos/kcl/kclvm/runtime/src/value
    
    the code of the file until where you have to start completion: //! Copyright The KCL Authors. All rights reserved.

use crate::*;

// cmp
impl ValueRef {
    pub fn cmp_equal(&self, x: &Self) -> bool {
        match *self.rc.borrow() {
            Value::int_value(a) => match *x.rc.borrow() {
                Value::int_value(b) => a == b,
                Value::float_value(b) => a as f64 == b,
                _ => false,
            },
            Value::float_value(a) => match *x.rc.borrow() {
                Value::int_value(b) => a == b as f64,
                Value::float_value(b) => a == b,
                _ => false,
            },
            _ => match (&*self.rc.borrow(), &*x.rc.borrow()) {
                (Value::undefined, Value::undefined) => true,
                (Value::none, Value::none) => true,
                (Value::bool_value(a), Value::bool_value(b)) => *a == *b,
                (Value::str_value(a), Value::str_value(b)) => *a == *b,
                (Value::list_value(a), Value::list_value(b)) => {
                    if a.values.len() != b.values.len() {
                        return false;
                    }
                    for i in 0..a.values.len() {
                        if !a.values[i].cmp_equal(&b.values[i]) {
                            return false;
                        }
                    }
                    true
                }
                (Value::dict_value(a), Value::dict_value(b)) => {
                    if a.values.len() != b.values.len() {
                        re
    
    pub fn cmp_greater_than_or_equal(&self, x: &Self) -> bool {
        match &*self.rc.borrow() {
            Value::int_value(a) => match &*x.rc.borrow() {
                Value::int_value(b) => *a >= *b,
                Value::float_value(b) => (*a as f64) >= *b,
                Value::bool_value(b) => *a >= (*b as i64),
                _ => panic!(
                    "'>=' not supported between instances of '{}' and '{}'",
                    self.type_str(),
                    x.type_str()
                ),
            },
            Value::float_value(a) => match &*x.rc.borrow() {
                Value::int_value(b) => *a >= *b as f64,
                Value::float_value(b) => *a >= *b,
                Value::bool_value(b) => *a >= ((*b as i64) as f64),
                _ => panic!(
                    "'>=' not supported between instances of '{}' and '{}'",
                    self.type_str(),
                    x.type_str()
                ),
            },
            Value::bool_value(a) => match &*x.rc.borrow() {
                Value::int_value(b) => (*a as i64) >= *b,
                Value::float_value(b) => ((*a as i64) as f64) >= *b,
                Value::bool_value(b) => *a >= *b,
                _ => panic!(
                    "'>=' not supported between instances of '{}' and '{}'",
                    self.type_str(),
                    x.type_str()
                ),
            },
            Value::str_value(a) => match &*x.rc.borrow() {
                Value::str_value(b) => *a >= *b,
                _ => panic!(
                    "'>=' not supported between instances of '{}' and '{}'",
                    self.type_str(),
                    x.type_str()
                ),
            },
            Value::list_value(a) => match &*x.rc.borrow() {
                Value::list_value(b) => {
                    let len_a = a.values.len();
                    let len_b = b.values.len();
                    let len_min = if len_a >= len_b { len_b } else { len_a };
                    for i in 0..len_min {
                        let value1 = &a.values[i];
                        let value2 = &b.values[i];
                        if !value1.cmp_equal(value2) {
                            return value1.cmp_greater_than_or_equal(value2);
                        }
                    }
                    len_a >= len_b
                }
                _ => panic!(
                    "'>=' not supported between instances of '{}' and '{}'",
                    self.type_str(),
                    x.type_str()
                ),
            },
            _ => panic!(
                "'>=' not supported between instances of '{}' and '{}'",
                self.type_str(),
                x.type_str()
            ),
        }
    }