package main

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) nextInt64() int64 {
	sign := int64(1)
	val := int64(0)
	b, _ := fs.r.ReadByte()
	for (b < '0' || b > '9') && b != '-' {
		b, _ = fs.r.ReadByte()
	}
	if b == '-' {
		sign = -1
		b, _ = fs.r.ReadByte()
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int64(b-'0')
		b, _ = fs.r.ReadByte()
	}
	return val * sign
}

func (fs *FastScanner) nextInt() int {
	return int(fs.nextInt64())
}

type BIT struct {
	n   int
	bit []int
}

func NewBIT(n int) *BIT {
	return &BIT{n: n, bit: make([]int, n+2)}
}

func (b *BIT) Add(i, delta int) {
	for i <= b.n {
		b.bit[i] += delta
		i += i & -i
	}
}

func (b *BIT) Sum(i int) int {
	res := 0
	for i > 0 {
		res += b.bit[i]
		i -= i & -i
	}
	return res
}

func (b *BIT) Kth(k int) int {
	if k <= 0 {
		return 0
	}
	idx := 0
	bitMask := 1
	for bitMask<<1 <= b.n {
		bitMask <<= 1
	}
	for d := bitMask; d > 0; d >>= 1 {
		nidx := idx + d
		if nidx <= b.n && b.bit[nidx] < k {
			k -= b.bit[nidx]
			idx = nidx
		}
	}
	if idx+1 > b.n {
		return 0
	}
	return idx + 1
}

func (b *BIT) NextAtLeast(x int) int {
	if x < 1 {
		x = 1
	}
	if x > b.n {
		return 0
	}
	s0 := b.Sum(x - 1)
	tot := b.Sum(b.n)
	if tot-s0 <= 0 {
		return 0
	}
	return b.Kth(s0 + 1)
}

func main() {
	fs := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	n := fs.nextInt()
	p := make([]int, n)
	indeg := make([]int, n)
	for i := 0; i < n; i++ {
		pi := fs.nextInt() - 1
		p[i] = pi
		indeg[pi]++
	}
	a := make([]int64, n)
	maxA := int64(0)
	for i := 0; i < n; i++ {
		a[i] = fs.nextInt64()
		if a[i] > maxA {
			maxA = a[i]
		}
	}

	// find sources (zero indegree)
	sources := make([]int, 0)
	for i := 0; i < n; i++ {
		if indeg[i] == 0 {
			sources = append(sources, i)
		}
	}
	s := len(sources)

	var T int64
	if maxA <= int64(n) {
		T = 0
	} else {
		// compute R = max a on sources
		var R int64 = 0
		for _, idx := range sources {
			if a[idx] > R {
				R = a[idx]
			}
		}
		if s == 0 {
			T = 0
		} else {
			T = (R - int64(n)) / int64(s)
			if T < 1 {
				T = 1
			}
		}
	}

	// binary lifting for p^T
	maxBit := 0
	if T > 0 {
		for (1 << uint(maxBit)) <= int(T) {
			maxBit++
		}
	}
	up := make([][]int, maxBit)
	if maxBit > 0 {
		up[0] = make([]int, n)
		for i := 0; i < n; i++ {
			up[0][i] = p[i]
		}
		for k := 1; k < maxBit; k++ {
			up[k] = make([]int, n)
			for i := 0; i < n; i++ {
				up[k][i] = up[k-1][up[k-1][i]]
			}
		}
	}

	f := make([]int, n)
	for i := 0; i < n; i++ {
		idx := i
		if T > 0 {
			for k := 0; k < maxBit; k++ {
				if (T>>uint(k))&1 == 1 {
					idx = up[k][idx]
				}
			}
		}
		f[i] = idx
	}

	// groups by target
	groups := make([][]int, n)
	for i := 0; i < n; i++ {
		g := f[i]
		groups[g] = append(groups[g], i)
	}

	// image set and leaders
	inImage := make([]bool, n)
	leader := make([]int, n)
	for i := 0; i < n; i++ {
		leader[i] = -1
		if len(groups[i]) > 0 {
			inImage[i] = true
			minIdx := groups[i][0]
			for _, v := range groups[i] {
				if v < minIdx {
					minIdx = v
				}
			}
			leader[i] = minIdx
		}
	}

	// reserved minima values
	reserved := make([]bool, n+1)
	for j := 0; j < n; j++ {
		if inImage[j] {
			v := a[j]
			if v >= 1 && v <= int64(n) {
				reserved[int(v)] = true
			}
		}
	}

	// BIT for non-reserved
	bit := NewBIT(n)
	for v := 1; v <= n; v++ {
		if !reserved[v] {
			bit.Add(v, 1)
		}
	}

	// assign b
	bAns := make([]int, n)
	for i := 0; i < n; i++ {
		t := f[i]
		if inImage[t] {
			v := a[t]
			if i == leader[t] {
				bAns[i] = int(v)
			} else {
				lb := int(v) + 1
				pos := bit.NextAtLeast(lb)
				bAns[i] = pos
				bit.Add(pos, -1)
			}
		} else {
			pos := bit.NextAtLeast(1)
			bAns[i] = pos
			bit.Add(pos, -1)
		}
	}

	for i := 0; i < n; i++ {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, bAns[i])
	}
	fmt.Fprintln(out)
}