module pair_stack
    implicit none
    private
    integer, allocatable:: stack(:)
    integer:: depth, max_depth
    public:: init, pop, push, is_remaining

contains
    subroutine init(x)
        integer, intent(in):: x
        max_depth = x
        allocate(stack(x))
        stack(:) = 0
        depth = 0
    end subroutine

    subroutine pop(a)
        integer, intent(out):: a
        if (depth <= 0)stop '-- --Stack is empty'
        a = stack(depth)
        depth = depth - 1
        ! print*, '-- -- poped =>', a, b
    end subroutine

    subroutine push(a)
        integer, intent(in):: a
        if (depth >= max_depth)stop '-- --Stack over flow'
        ! print*, '-- -- pushed =>', a, b
        depth = depth + 1
        stack(depth) = a
    end subroutine

    function is_remaining() result(ret)
        logical:: ret
        if (depth <= 0)then
            ret = .false.
        else
            ret = .true.
        end if
    end function
end module


program main
    implicit none
    integer:: N, Q
    integer, allocatable:: ab(:, :), px(:, :), counter(:)
    integer:: i

    read*, N,Q
    allocate(ab(2, N-1), px(2, Q), counter(N))
    read*, ab(1:2, 1:N-1)
    read*, px(1:2, 1:Q)
    counter(1:N) = 0
    
    do i=1,Q
        counter(px(1,i)) = counter(px(1, i)) + px(2,i) 
    end do

    ! call quick_sort(ab)

    do i=1,N-1
        counter(ab(2,i)) = counter(ab(2,i)) + counter(ab(1,i))
    end do

    do i = 1, N
        write(*, '(i0,1x)',advance='no')counter(i)
    end do
    print*, ''

    


contains
    subroutine quick_sort(arr)
        use pair_stack
        integer, intent(inout):: arr(:, :)
        integer:: p_seek, sorted,trg
        integer:: afa
        integer:: i,j

        do i = 1,N-1
            if(arr(1,i) == 1)then
                call swap(arr(1,i), arr(1,1))
                call swap(arr(2,i), arr(2,1))
                exit
            endif
        enddo
        call init(N+1)
        call push(arr(1,1))
        call push(arr(2,1))
        sorted = 1
        do while(is_remaining())
            call pop(trg)
            do i = sorted+1, N-1
                if(arr(1,i) == trg)then
                    call swap(arr(1,i), arr(1,sorted+1))
                    call swap(arr(2,i), arr(2,sorted+1))
                    sorted = sorted + 1
                    call push(arr(1,sorted))
                    call push(arr(2,sorted))
                    exit
                else if(arr(2,i) == trg)then
                    call swap(arr(1,i), arr(2,i))
                    call swap(arr(1,i), arr(1,sorted+1))
                    call swap(arr(2,i), arr(2,sorted+1))
                    sorted = sorted + 1
                    call push(arr(1,sorted))
                    call push(arr(2,sorted))
                    exit
                end if
            end do
        end do
    end subroutine

    subroutine swap(a,b)
        integer, intent(inout):: a,b
        integer:: r
        r = a; a = b; b = r
    end subroutine
end program main