Given an integer array `nums`

, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once. You can return the answer in **any order**.

**Follow up: **Your algorithm should run in linear runtime complexity. Could you implement it using only constant space complexity?

**Example 1:**

Input:nums = [1,2,1,3,2,5]Output:[3,5]Explanation:[5, 3] is also a valid answer.

**Example 2:**

Input:nums = [-1,0]Output:[-1,0]

**Example 3:**

Input:nums = [0,1]Output:[1,0]

**Constraints:**

`2 <= nums.length <= 3 * 10`

^{4}`-2`

^{31}<= nums[i] <= 2^{31}- 1- Each integer in
`nums`

will appear twice, only two integers will appear once.

```
struct Solution;
impl Solution {
fn single_number(nums: Vec<i32>) -> Vec<i32> {
let mut bitmask = 0;
for &num in &nums {
bitmask ^= num;
}
let diff = bitmask & (-bitmask);
let mut x = 0;
for &num in &nums {
if diff & num != 0 {
x ^= num;
}
}
vec![x, bitmask ^ x]
}
}
#[test]
fn test() {
let nums = vec![1, 2, 1, 3, 2, 5];
let res = vec![3, 5];
assert_eq!(Solution::single_number(nums), res);
}
```