You can easily test the behavior of the overflow. I started near the max unsigned long value so it wouldn't take long.

```
void setup() {
Serial.begin(9600);
}
unsigned long MyValue=4294967290 ;
void loop() {
MyValue=MyValue+1;
Serial.println(MyValue,DEC);
delay(100);
}
```

And the output:

```
4294967292
4294967293
4294967294
4294967295
0
1
2
3
4
5
```

The result makes sense. Any byte value can range from 00'x fo FF'x. So if you add 1 to FF'x, it becomes 100'x, but that won't fit into a single byte, so we consider it overflow. The most significant digit is truncated. so you're left with 00'x. Overflows of unsigned integers behave this way. They behave exactly the opposite for underflow. It wraps from 00'x to FF'x.

Now, with signed integers, it's a bit more complicated because the numbers are stored in 2's compliment. (You'll only notice a difference for negative numbers). The signed variable stores the same number of total values as an unsigned variable does, but they range from -x to +x intead of the unsigned range of 0 to +2x. When the signed integer overflows, it's essentially turning on the sign bit. The only way to detect a signed integer overflow is to take the signs of both operands and compare them to the sign of the result.

```
Positive + Positive = Positive
Positive + Negative = Either, depending on the magnitude of the operands.
Negative + Negative = Negative
Negative + Positive = Either, depending on the magnitude of the operands.
```

In your case, When micros() overflows, it resets to zero.

```
timecount=micros() - startTime;
```

When you run your program, it will look like timecount increases from zero to 4294967295-startTime. At which point mills() overflows and resets to zero. Zero-startTime underflows and results in a large number. So timecount appears to keep counting upward until it reaches it's max value of 4294967295 and resets to zero. At the point that timecount resets to zero, mills() = startTime again.

Once mills() is greater than startTime again, it will act as it did when it first started.

Essentially, it will loop from 0 to 4294967295 counting up over and over again.