use strict;
    use warnings;
    use Data::Dumper;
    use Carp;
    
    
    my %graphs = ( 1 => [2,3], 2 => [1,3,4,5], 3 =>[1,2,4,5], 4 => [2,3,5], 5 => [2,3,4]);
    my @path = eulerPath(%graphs);
    
    
    sub eulerPath {
    
        my %graph = @_;
    
        # count the number of vertices with odd degree
        my @odd = ();
        foreach my $vert ( sort keys %graph ) {
            my @edg = @{ $graph{$vert} };
    
            my $size = scalar(@edg);
            if ( $size % 2 != 0 ) {
                push @odd, $vert;
            }
        }
    
        push @odd, ( keys %graph )[0];
    
        if ( scalar(@odd) > 3 ) {
            return "None";
    
        }
    
        my @stack = ( $odd[0] );
        my @path  = ();
    
        while (@stack) {
            my $v = $stack[-1];
    
            if ( $graph{$v} ) {
                my $u = ( @{ $graph{$v} } )[0];
                push @stack, $u;
    
                # Find index of vertice v in graph{$u}
    
                my @graphu = @{ $graph{$u} };  # This is line 54.
                my ($index) = grep $graphu[$_] eq $v, 0 .. $#graphu;
                delete @{ $graph{$u} }[$index];
                delete @{ $graph{$v} }[0];
    
            }
            else {
    
                push @path, pop(@stack);
            }
    
        }
    
        print Dumper \@path;
    
        return @path;
    }

##</code><code>##

    Use of uninitialized value in hash element at euler.pl line 54

##</code><code>##

    $VAR = [5, 4, 3, 5, 2, 3, 1, 2, 4];

##</code><code>##

    def eulerPath(graph):
        # counting the number of vertices with odd degree
        odd = [ x for x in graph.keys() if len(graph[x])&1 ]
        print odd
        odd.append( graph.keys()[0] )
    
    
        if len(odd)>3:
            return None
    
        stack = [ odd[0] ]
        path = []
    
        # main algorithm
        while stack:
            v = stack[-1]
            if graph[v]:
                u = graph[v][0]
                stack.append(u)
                # deleting edge u-v
                #print graph[u][ graph[u].index(v) ]
                #print graph[u].index(v)
                del graph[u][ graph[u].index(v) ]
                del graph[v][0]
            else:
                path.append( stack.pop() )
    
        return path
    
    stack_ = eulerPath({ 1:[2,3], 2:[1,3,4,5], 3:[1,2,4,5], 4:[2,3,5], 5:[2,3,4] })
    print stack_