#[inline]
fn encode_into(mut value: u128, result: &mut Vec<u8>) {
    while value > 0 {
        let mut item = value % 128;
        value /= 128;
        if value > 0 {
            item += 128;
        }
        result.push(item as u8);
    }
}

#[inline]
fn encode(value: u128) -> Vec<u8> {
    let mut result = Vec::new();
    encode_into(value, &mut result);
    result
}

#[inline]
fn encode_many(values: &[u128]) -> Vec<u8> {
    let mut result = Vec::new();
    for i in values {
        encode_into(*i, &mut result);
    }
    result
}

#[inline]
fn decode(mut bytes: &[u8]) -> Result<(u128, &[u8]), &'static str> {
    let mut result = 0;
    let mut multipler = 1;
    while let Some((item, rest_bytes)) = bytes.split_first() {
        let item = *item as u128;
        if item < 128 {
            return Ok((result + item * multipler, rest_bytes));
        } else {
            result += (item - 128) * multipler;
            multipler *= 128;
            bytes = rest_bytes;
        }
    }
    Err("wrong encoding or not enough data")
}

#[inline]
fn decode_many(mut bytes: &[u8]) -> (Vec<u128>, &[u8]) {
    let mut result = Vec::new();
    'decode_loop: loop {
        match decode(bytes) {
            Ok((item, new_bytes)) => {
                result.push(item);
                bytes = new_bytes;
            }
            Err(_) => {
                break 'decode_loop;
            }
        }
    }
    (result, bytes)
}

fn main() {
    dbg!(encode(12));
    let _ = dbg!(decode(&[12]));
    dbg!(encode(112));
    let _ = dbg!(decode(&[112]));
    dbg!(encode(512));
    let _ = dbg!(decode(&[128, 4, 5]));
    dbg!(encode(1512));
    let _ = dbg!(decode(&[232, 11, 128, 4]));
    dbg!(encode_many(&[1512, 512, 5]));
    let _ = dbg!(decode_many(&[232, 11, 128, 4, 5, 130]));
}