Here is an example for "long long": 

#include <stdio.h>

int main(void)
{
	long long a = 1LL <<  48 ;
	printf("%lld\n", a);
	return  0 ;
}

# include <iostream>
# include <vector>
# define MAX  15 
using namespace std;

vector <pair<int, int> > v[ 10000 ]; //Adjacency list
vector <pair <int,int> >::iterator it;
int cost[ 10000 ]; //Cost of each vertex

//Compare function
bool cmp(int a, int b)
{
    return cost[a]<cost;
}

//Class Node
class Node{
    public:
        int key; //Value
        int size; //Size of the child list
        int degree; //Degree
        Node *child; //Reference to the first element of the child list
        Node *left; //Left element
        Node *right; //Right element
        //Constructor
        Node(int value)
        {
            this->size= [b]0 ;
            this->key=value;
            this->degree= 0 ;
            this->child=NULL;
            this->left=this;
            this->right=this;
        }
        //Destructor
        ~Node(){}
        //Methods
        void insert(Node *n);
        //Print the child list
        void printNode() {
            int i, t=this->size;
            printf("%d (", this->key);
            Node *n=this->child;
            for (i= 0 ;i<t;i++) {
                n->printNode();
                n=n->right;
            }
            printf(") ");
        }
};

//Fibonacci Heap class
class FibonacciHeap
{
    public:
        int size; //Number of elements in the root list
        Node *minimum; //Reference to the element with the smallest value
        Node *first; //Reference to the first element of the root list
        //Constructor
        FibonacciHeap() {
            this->size= 0 ;
            this->minimum=NULL;
            this->first=NULL;
        }
        //Destructor
        ~FibonacciHeap(){};
        //Methods
        bool empty();
        void insert(Node *n);
        void merge(FibonacciHeap *fh);
        int minKey();
        void consolidate();
        //Print the Heap elements
        void printHeap()
        {
            int i;
            Node *x=this->first;
            for (i= 0 ;i<this->size;i++) {
                x->printNode();
                putchar(' ');
                x=x->right;
            }
            putchar('\n');
        }
};

//Function that inserts a child into the child list. O( 1 )
void Node::insert(Node *n)
{
    if (this->size== 0 ) {
        this->child=n;
        this->child->right=n;
        this->child->left=n;
    }
    else {
        n->right=this->child;
        n->left=this->child->left;
        this->child->left->right=n;
        this->child->left=n;
    }
    this->size++;
    this->degree++;
}

/*Function that returns true if the heap is empty, otherwise, returns false.
O(1)*/
bool FibonacciHeap::empty()
{
    return this->size== 0 ;
}

/* Function that inserts a node into the root list. O(1)*/
void FibonacciHeap::insert(Node *n)
{
    if (this->size== 0 ) {
        this->first=n;
        this->first->right=this->first;
        this->first->left=this->first;
        this->minimum=this->first;
    }
    else {
        n->right=this->first;
        n->left=this->first->left;
        this->first->left->right=n;
        this->first->left=n;
        if (cmp(n->key, this->minimum->key)) {
            this->minimum=n;
        }
    }
    this->size++;
}

/*Function that returns the key of the node with the smallest value.
O(1) + O(consolidate)*/
int FibonacciHeap::minKey()
{
    int t;
    Node *temp=this->minimum, *childs=this->minimum->child;
    if (temp!=NULL) {
        this->size--;
        if (this->size== 0 ) {
            this->first=NULL;
            this->minimum=NULL;
        }
        else {
            temp->left->right=temp->right;
            temp->right->left=temp->left;
            this->minimum=temp->right;
            if (this->first->key==temp->key) {
                this->first=this->first->right;
            }
        }
        if (childs!=NULL) {
            if (this->size== 0 ) {
                this->first=childs;
                this->minimum=childs;
            }
            else {
                childs->left->right=this->minimum;
                this->minimum->left->right=childs;
                this->minimum->left=childs->left;
                childs->left=this->minimum->left;
            }
            this->size+=temp->size;
        }
        this->consolidate();
        return temp->key;
    }
}

/*Function that consolidates the root list. O(MAX), 
where MAX=lg(n), 0<=n<=10000*/
void FibonacciHeap::consolidate()
{
    int i, d, aux=this->size;
    Node *vv[MAX], *x=this->minimum, *y, *temp, *next;
    for (i= 0 ;i<MAX;i++) {
        vv[i]=NULL;
    }
    for (i= 0 ;i<aux;i++) {
        d=x->degree;
        next=x->right;
        while (vv[d]!=NULL)  {
            y=vv[d];
            if (x->key > y->key) {
                y->insert(x);
                x=y;
            }
            else {
                x->insert(y);
            }
            vv[d]=NULL;
            d++;
        }
        vv[d]=x;
        x=next;
    }
    this->first=NULL;
    this->minimum=NULL;
    this->size= 0 ;
    for (i= 0 ;i<MAX;i++) {
        if (vv[i]!=NULL) {
            this->insert(vv[i]);
        }
    }
}

int dijkstra(int ini, int fin){
    int i,j;
    FibonacciHeap *fh=new FibonacciHeap();
    memset(cost,0x3f3f3f3f,sizeof cost);
    cost[ini]= 0 ;
    fh->insert(new Node(ini));
    while(!fh->empty()){
        i=fh->minKey();
        if (i==fin)
            break;
        for(it=v[i].begin();it!=v[i].end();it++){
            if (cost[i]+(*it).second<cost[(*it).first]){
                cost[(*it).first]=cost[i]+(*it).second;
                fh->insert(new Node((*it).first));
            }
        }
    }
    return cost[fin];
}

int read(){
    int r= 0 ;
    char c;
    while(!isdigit(c=getchar()));
    while(isdigit(c)){
        r=r* 10 +(c-'0');
        c=getchar();
    }
    return r;
}

int main(){
    char c[ 10000 ][ 11 ],ini[ 11 ],fin[ 11 ];
    int t,n,i,j,k,m;
    pair <int, int> p;
    t=read();
    while(t--){
        n=read();
        for(i= 0 ;i<n;i++){
            v[i].clear();
            scanf("%s",c[i]);
            m=read();
            for(j= 0 ;j<m;j++){
                p.first=read()- 1 ;
                p.second=read();
                v[i].push_back(p);
            }
        }
        m=read();
        for(i= 0 ;i<m;i++){
            scanf("%s%s",ini,fin);
            for(j= 0 ;j<n && strcmp(ini,c[j])!= 0 ;j++);
            for(k= 0 ;k<n && strcmp(fin,c[k])!= 0 ;k++);
            printf("%d\n",dijkstra(j,k));
        }
    }
    return  0 ;
}