Design your implementation of the linked list. You can choose to use a singly or doubly linked list.
A node in a singly linked list should have two attributes: `val` and `next`. `val` is the value of the current node, and `next` is a pointer/reference to the next node.
If you want to use the doubly linked list, you will need one more attribute `prev` to indicate the previous node in the linked list. Assume all nodes in the linked list are 0-indexed.

Implement the `MyLinkedList` class:

• `MyLinkedList()` Initializes the `MyLinkedList` object.
• `int get(int index)` Get the value of the `indexth` node in the linked list. If the index is invalid, return `-1`.
• `void addAtHead(int val)` Add a node of value `val` before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
• `void addAtTail(int val)` Append a node of value `val` as the last element of the linked list.
• `void addAtIndex(int index, int val)` Add a node of value `val` before the `indexth` node in the linked list. If `index` equals the length of the linked list, the node will be appended to the end of the linked list. If `index` is greater than the length, the node will not be inserted.
• `void deleteAtIndex(int index)` Delete the `indexth` node in the linked list, if the index is valid.

Example 1:

```Input
[[], [1], [3], [1, 2], [1], [1], [1]]
Output
[null, null, null, null, 2, null, 3]

Explanation
```

Constraints:

• `0 <= index, val <= 1000`
• At most `2000` calls will be made to `get``addAtHead``addAtTail``addAtIndex` and `deleteAtIndex`.

``````use rustgym_util::*;

#[derive(Debug, PartialEq, Eq, Clone, Default)]
}

fn new() -> Self {
}

fn get(&self, index: i32) -> i32 {
if index < 0 {
return -1;
}
let mut i = 0;
while let Some(node) = link {
if i == index {
return node.val;
}
i += 1;
}
-1
}

}

fn add_at_tail(&mut self, val: i32) {
while let Some(node) = link {
}
}

fn add_at_index(&mut self, index: i32, val: i32) {
if index <= 0 {
} else {
let mut i = 0;
while let Some(node) = link {
if index == i + 1 {
return;
} else {
i += 1;
}
}
}
}

fn delete_at_index(&mut self, index: i32) {
if index < 0 {
return;
}
let mut i = 0;
loop {
None => {
return;
}
Some(node) if index == i => {
return;
}
Some(node) => {
i += 1;
}
}
}
}
}

#[test]
fn test() {