why am I getting error on: temporary$=$hash$\_$table$[$second$\_$index$]$; and how to fix it$?$

package spiderman;

public class creatingHT $\{$

$//$to create the hash table, you need to first perform the hash function

$//$Hash Function:

public static int hashCode$($ ClusterNode temporary, int size$)\{$

int num$\_$dime $=$ temporary.getDimen$\_$num$()$;

int i $=$ num$\_$dime $\%$ size;

return i;

$\}$

$//$ReHash Function:

$//$to rehash, you need two tables: one which is prev and one which is current

private static void reHash$($ ClusterNode$[]$ prev, ClusterNode$[]$ current $)\{$

int new$\_$size $=$ current.length; $//$you need a new size inorder to re$-$hash your hash table.

for $($ int a $=0$; a $<$ prev.length; a$++)\{//$go through the LL of ClusterNode

ClusterNode prev$\_$pointer $=$ prev$[$a$]$; $//$pointer

while $($ prev$\_$pointer $!=$ null $)\{$

ClusterNode current$\_$pointer $=$ prev$\_$pointer;

prev$\_$pointer $=$ prev$\_$pointer.getNext$()$; $//$go to the next node

int b $=$ hashCode$($current$\_$pointer, new$\_$size$)$; $//$creating new index which uses the Hash Function, we can use this and create a new hash table.

ClusterNode temporary $=$ current$[$b$]$;

current$[$b$]=$ current$\_$pointer;

current$[$b$].$setNext$($temporary$)$;

$\}$

$\}$

$\}$

public static ClusterNode$[]$ createHashTable$($String in$)\{$

$//$create a tracker to check how many nodes there are in a Hash Table

int tracker $=0$;

StdIn.setFile$($in$)$; $//$ the in is the dimension.in which we are taking in

$/*$Step $1$:

$*$ DimensionInputFile name is passed through the command line as args$[0]$

$*$ Read from the DimensionsInputFile with the format:

$*1.$ The first line with three numbers:

$*$ i$.$ a $($int$)$: number of dimensions in the graph

$*$ ii$.$ b $($int$)$: the initial size of the cluster table prior to rehashing

$*$ iii. c $($double$)$: the capacity$($threshold$)$ used to rehash the cluster table $*/$

int a $=$ StdIn.readInt$()$;

int b $=$ StdIn.readInt$()$;

double c $=$ StdIn.readDouble$()$;

StdIn.readLine$()$;

ClusterNode$[]$ hash$\_$table $=$ new ClusterNode$[$b$]$;

while $(!$StdIn.isEmpty$())\{$

if $($tracker $>=$ c$)\{$

ClusterNode$[]$ current $=$ new ClusterNode$[$b$*2]$;

b $=$ b$*2$;

c $=$ c$*2$;

$//$call the rehash method to rehash everything copied from the current to the new table.

reHash$($hash$\_$table, current$)$;

hash$\_$table $=$ current;

$\}$

int num$\_$dime $=$ StdIn.readInt$()$;

int canon$\_$events $=$ StdIn.readInt$()$;

int dimen$\_$weight $=$ StdIn.readInt$()$;

ClusterNode Node $=$ new ClusterNode$($num$\_$dime, canon$\_$events, dimen$\_$weight, null$)$;

int i $=$ hashCode$($Node$,$ b$)$;

ClusterNode temporary $=$ hash$\_$table$[$i$]$;

hash$\_$table$[$i$]=$ Node;

hash$\_$table$[$i$].$setNext$($temporary$)$;

tracker $=$ tracker$++$;

System.out.println$()$;

StdIn.readLine$()$;

$\}$

int length $=$ hash$\_$table.length;

for $($ int indexes $=0$; indexes $<$ hash$\_$table.length; indexes$++)\{$

$//$adding the first two nodes of the hash table and adding it at the end of the table which we have.

$//$you need two indexes to do this. one for each node.

int first$\_$index $=$ indexes $-1$;

int second$\_$index $=$ indexes $-2$;

if $($ first$\_$index $<0)\{//$you need to check for num's $<0.$

first$\_$index $=$ length $+$ first$\_$index;

$\}$

if $($ second$\_$index $<0)\{$

second$\_$index $=$ length $+$ second$\_$index;

$\}$

ClusterNode temporary $=$ hash$\_$table$[$first$\_$index$]$;

ClusterNode first$\_$node $=$ new ClusterNode$($temporary$.$getDimen$\_$num$(),$ temporary.getCanon$\_$events$(),$ temporary.getDimen$\_$weight$(),$ null $)$;

temporary $=$ hash$\_$table$[$second$\_$index$]$;

ClusterNode second$\_$node $=$ new ClusterNode$($temporary$.$getDimen$\_$num$(),$ temporary.getCanon$\_$events$(),$ temporary.getDimen$\_$weight$(),$ null $)$;

$//$to add the nodes, you have to traverse through the LL in the hash$\_$table.

ClusterNode pointer $=$ hash$\_$table$[$indexes$]$;

while$($ pointer.getNext$()!=$ null $)\{//$check if the list is not empty

pointer $=$ pointer.getNext$()$;

$\}$

$//$go to the end of the LL

pointer.setNext$($first$\_$node$)$;

pointer $=$ pointer.getNext$()$;

pointer.setNext$($second$\_$node$)$;

$\}$

return hash$\_$table;

$\}$

$\}$