1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

pub trait Zigzag<T> {
    fn zigzag(self) -> T;
}

impl Zigzag<u8> for i8 {
    #[inline]
    fn zigzag(self) -> u8 {
        ((self << 1) ^ (self >> 7)) as u8
    }
}

impl Zigzag<i8> for u8 {
    #[inline]
    fn zigzag(self) -> i8 {
        ((self >> 1) as i8) ^ (-((self & 1) as i8))
    }
}

impl Zigzag<u16> for i16 {
    #[inline]
    fn zigzag(self) -> u16 {
        ((self << 1) ^ (self >> 15)) as u16
    }
}

impl Zigzag<i16> for u16 {
    #[inline]
    fn zigzag(self) -> i16 {
        ((self >> 1) as i16) ^ (-((self & 1) as i16))
    }
}

impl Zigzag<u32> for i32 {
    #[inline]
    fn zigzag(self) -> u32 {
        ((self << 1) ^ (self >> 31)) as u32
    }
}

impl Zigzag<i32> for u32 {
    #[inline]
    fn zigzag(self) -> i32 {
        ((self >> 1) as i32) ^ (-((self & 1) as i32))
    }
}

impl Zigzag<u64> for i64 {
    #[inline]
    fn zigzag(self) -> u64 {
        ((self << 1) ^ (self >> 63)) as u64
    }
}

impl Zigzag<i64> for u64 {
    #[inline]
    fn zigzag(self) -> i64 {
        ((self >> 1) as i64) ^ (-((self & 1) as i64))
    }
}

impl Zigzag<u128> for i128 {
    #[inline]
    fn zigzag(self) -> u128 {
        ((self << 1) ^ (self >> 127)) as u128
    }
}

impl Zigzag<i128> for u128 {
    #[inline]
    fn zigzag(self) -> i128 {
        ((self >> 1) as i128) ^ (-((self & 1) as i128))
    }
}

impl Zigzag<usize> for isize {
    #[inline]
    fn zigzag(self) -> usize {
        ((self << 1) ^ (self >> (usize::BITS - 1))) as usize
    }
}

impl Zigzag<isize> for usize {
    #[inline]
    fn zigzag(self) -> isize {
        ((self >> 1) as isize) ^ (-((self & 1) as isize))
    }
}