```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n int
	fmt.Fscan(in, &n)

	adj := make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	children := make([][]int, n+1)
	parent := make([]int, n+1)
	order := make([]int, 0, n)
	
	// Iterative DFS to build tree structure and traversal order
	stack := []int{1}
	parent[1] = 0 // 0 indicates no parent
	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, u)
		for _, v := range adj[u] {
			if v != parent[u] {
				parent[v] = u
				children[u] = append(children[u], v)
				stack = append(stack, v)
			}
		}
	}

	l := make([]int, n+1)
	r := make([]int, n+1)
	time := 0

	// Set l[1]
	time++
	l[1] = time

	// Stack for the custom traversal logic
	// frame: {u, index, phase}
	// phase 0: opening children (setting l values)
	// phase 1: closing children (recursing and setting r values)
	type frame struct {
		u     int
		idx   int
		phase int
	}

	dfsStack := []frame{{1, 0, 0}}

	for len(dfsStack) > 0 {
		top := dfsStack[len(dfsStack)-1]
		dfsStack = dfsStack[:len(dfsStack)-1]

		u := top.u
		k := top.idx
		phase := top.phase
		kids := children[u]

		if phase == 0 {
			if k < len(kids) {
				v := kids[k]
				time++
				l[v] = time
				dfsStack = append(dfsStack, frame{u, k + 1, 0})
			} else {
				time++
				r[u] = time
				dfsStack = append(dfsStack, frame{u, 0, 1})
			}
		} else {
			if k < len(kids) {
				v := kids[len(kids)-1-k]
				dfsStack = append(dfsStack, frame{u, k + 1, 1})
				dfsStack = append(dfsStack, frame{v, 0, 0})
			}
		}
	}

	for i := 1; i <= n; i++ {
		fmt.Fprintf(out, "%d %d\n", l[i], r[i])
	}
}
```