```python
def find_Element(arr, ranges, rotations, index):
    current_index = index

    # To find the original position of the element that ends up at `index`,
    # we can reverse the effect of each rotation, starting from the last one.
    for start, end in reversed(ranges):
        
        # Check if the current tracked index is within the range of this rotation.
        # If not, this rotation did not affect the element's position.
        if start <= current_index <= end:
            
            # Calculate the length of the subarray being rotated.
            range_length = end - start + 1
            
            # The number of right shifts can be taken modulo the range length,
            # as rotating by the length results in the original order.
            num_shifts = rotations % range_length
            
            # If the effective number of shifts is zero, this rotation has no effect.
            if num_shifts == 0:
                continue
            
            # Convert the absolute index to a relative position within the subarray.
            relative_pos = current_index - start
            
            # To find where the element came from, we apply the inverse of a right
            # shift, which is a left shift. An element at `relative_pos` came from
            # the position `num_shifts` to its left (circularly).
            # We add `range_length` to handle negative results before the modulo.
            original_relative_pos = (relative_pos - num_shifts + range_length) % range_length
            
            # Convert the original relative position back to an absolute index.
            current_index = start + original_relative_pos
            
    # After undoing all rotations, `current_index` is the original index
    # of the element that ends up at the target `index`.
    return arr[current_index]

```