fn main() {
    // edit this value for your decimal input
    let input = "85.125";
    let mut split = input.split('.');

    let integer = split.next().unwrap().parse::<i32>().unwrap();
    let (decimal, decimal_len) = if let Some(x) = split.next() {
        (x.parse::<i32>().unwrap(), x.len() as i32)
    } else {
        (0, 1)
    };

    let mut bits = [0; 32];

    bits[0] = if integer.signum() < 0 {
        1
    } else {
        0
    };

    let mut int_buf = [0; 32];
    let mut dec_buf = [0; 16];

    let pow = to_binary_int(integer, &mut int_buf[..]) - 1;
    to_binary_dec(decimal as f64 / 10.0_f64.powi(decimal_len), &mut dec_buf[..]);

    let exp = 127 + pow;
    to_binary_int(exp as i32, &mut bits[1..9]);

    copy_slice (&mut bits[9..10 + pow], &int_buf[int_buf.len() - pow..]);
    copy_slice (&mut bits[pow + 10..], &dec_buf[..]);

    println!("{:?}", bits);
}

fn copy_slice(target: &mut [i32], from: &[i32]) {
    target[..from.len()].iter_mut().zip(from.iter()).for_each(|x| {
       *x.0 = *x.1;
    });
}

fn to_binary_int(num: i32, buf: &mut [i32]) -> usize {
    let mut cur = num;
    let mut i = 0;
    while cur > 0 {
        let rem = cur % 2;
        cur /= 2;
        buf [i] = rem;
        i += 1;
    }
    buf.reverse();
    i
}

fn to_binary_dec(num: f64, buf: &mut [i32]) {
    let mut cur = num;
    let mut precision = Some(buf.len());

    let mut i = 0;

    while let Some(p) = precision {
        if p == 0 {
            precision = None;
        } else {
            cur *= 2.0;
            let bit = if cur as i32 == 1 {
                cur -= 1.0;
                1
            } else {
                0
            };
            buf[i] = bit;

            i += 1;
            precision = Some(p - 1);
        }
    }
}