Let's define a forest as a non-directed acyclic graph (also without loops and parallel edges). One day Misha played with the forest consisting of *n* vertices. For each vertex *v* from 0 to *n* - 1 he wrote down two integers, *degree*<sub class="lower-index">*v*</sub> and *s*<sub class="lower-index">*v*</sub>, were the first integer is the number of vertices adjacent to vertex *v*, and the second integer is the XOR sum of the numbers of vertices adjacent to *v* (if there were no adjacent vertices, he wrote down 0). 

Next day Misha couldn't remember what graph he initially had. Misha has values *degree*<sub class="lower-index">*v*</sub> and *s*<sub class="lower-index">*v*</sub> left, though. Help him find the number of edges and the edges of the initial graph. It is guaranteed that there exists a forest that corresponds to the numbers written by Misha.
The first line contains integer *n* (1 ≤ *n* ≤ 2<sup class="upper-index">16</sup>), the number of vertices in the graph.

The *i*-th of the next lines contains numbers *degree*<sub class="lower-index">*i*</sub> and *s*<sub class="lower-index">*i*</sub> (0 ≤ *degree*<sub class="lower-index">*i*</sub> ≤ *n* - 1, 0 ≤ *s*<sub class="lower-index">*i*</sub> &lt; 2<sup class="upper-index">16</sup>), separated by a space.
import sys
#sys.setrecursionlimit(10**7)
input = sys.stdin.readline

############ ---- Input Functions ---- ############
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return(map(int,input().split()))
############ ---- Input Functions ---- ############

def Misha_and_Forest():
    n = inp()

    xor_sum = []
    degree = []
    one_degree_nodes = []


    for node in range(n):
        u,s = invr()
        degree.append(u)
        xor_sum.append(s)
        
        if u == 1:
            one_degree_nodes.append(node)
    
    outputStr = ''
    number_of_edges = 0
    while len(one_degree_nodes) > 0 :
        node = one_degree_nodes.pop(0)
        neighbour = xor_sum[node]
        outputStr += str(node) + ' ' + str(neighbour) + '\n'
        number_of_edges += 1
        degree[neighbour] -= 1
        xor_sum[neighbour] = xor_sum[neighbour] ^ node 

        if degree[neighbour] == 1:
            one_degree_nodes.append(neighbour)
        elif degree[neighbour] == 0:
            one_degree_nodes.remove(neighbour)
    
    print(number_of_edges)
    outputStr = outputStr.strip()
    print(outputStr)
    return 


Misha_and_Forest()