Please write a Rust function that takes a u64 input and returns the largest prime number less than that value.
Here is an example implementation of the function:

```
rustCopy codefn largest_prime_less_than(x: u64) -> u64 {
    if x <= 2 {
        return 0;
    }
    let mut n = x - 1;
    while n > 1 {
        if is_prime(n) {
            return n;
        }
        n -= 1;
    }
    0
}

fn is_prime(x: u64) -> bool {
    if x <= 1 {
        return false;
    }
    for i in 2..=(x as f64).sqrt() as u64 + 1 {
        if x % i == 0 {
            return false;
        }
    }
    true
}

```

This implementation first checks if the input `x` is less than or equal to 2, in which case it returns 0 since there are no prime numbers less than 2. Then, it starts from `x - 1` and decrements `n` until it finds the largest prime number less than `x`, which it returns. The helper function `is_prime` checks if a given number is prime or not by iterating over all the numbers up to the square root of the number and checking if the number is evenly divisible by any of them. If the number is not divisible by any of them, it is considered to be a prime number.
Does that function run in the optimal time complexity for the problem? If it does can you say what the complexity is; if it does not, can you write a better algorithm; and if it unsolved, can you tell me the runtime of the best know algorithm is?