diff --git a/patternGenerator/patterns/test_v2.alias b/patternGenerator/patterns/test_v2.alias
new file mode 100644
index 000000000..9ac446f6d
--- /dev/null
+++ b/patternGenerator/patterns/test_v2.alias
@@ -0,0 +1,4 @@
+BIT0 output0 1
+BIT1 output1 1
+BIT2 output2 1
+BIT3 output3 1
\ No newline at end of file
diff --git a/patternGenerator/patterns/test_v2.p b/patternGenerator/patterns/test_v2.p
new file mode 100644
index 000000000..809db9456
--- /dev/null
+++ b/patternGenerator/patterns/test_v2.p
@@ -0,0 +1,97 @@
+//define signals and directions (Input, outputs, clocks)
+
+
+#define output0 0
+setoutput(output0);
+
+#define output1 1
+setoutput(output1);
+
+#define output2 2
+setoutput(output2);
+
+#define output3 3
+setoutput(output3);
+
+#define input0 4
+setinput(input0);
+
+#define input1 5
+setinput(input1);
+
+#define input2 6
+setinput(input2);
+
+#define input3 7
+setinput(input3);
+
+  
+#define PW pw()
+#define SB(x) setbit(x) 
+#define CB(x) clearbit(x)
+#define CLOCK  clearbit(CLKBIT); pw();setbit(CLKBIT);pw()
+#define LCLOCK  clearbit(CLKBIT); pw();setbit(CLKBIT);pw();clearbit(CLKBIT); pw()
+#define CLOCKS(x) for (i=0;i<x;i++) {clearbit(CLKBIT);pw(); setbit(CLKBIT); pw();}
+#define STOP setstop();
+#define START setstart();
+#define REPEAT(x) for (i=0;i<(x);i++) {pw();}
+#define DOFOR(x) for (j=0;j<(x);j++) {
+// }
+
+			     
+#define INST0 CB(output3);CB(output2);CB(output1);CB(output0);PW;
+#define INST1 CB(output3);CB(output2);CB(output1);SB(output0);PW;
+#define INST2 CB(output3);CB(output2);SB(output1);CB(output0);PW;
+#define INST3 CB(output3);CB(output2);SB(output1);SB(output0);PW;
+#define INST4 CB(output3);SB(output2);CB(output1);CB(output0);PW;
+#define INST5 CB(output3);SB(output2);CB(output1);SB(output0);PW;
+#define INST6 CB(output3);SB(output2);SB(output1);CB(output0);PW;
+#define INST7 CB(output3);SB(output2);SB(output1);SB(output0);PW;
+#define INST8 SB(output3);CB(output2);CB(output1);CB(output0);PW;
+#define INST9 SB(output3);CB(output2);CB(output1);SB(output0);PW;
+#define INST10 SB(output3);CB(output2);SB(output1);CB(output0);PW;
+#define INST11 SB(output3);CB(output2);SB(output1);SB(output0);PW;
+#define INST12 SB(output3);SB(output2);CB(output1);CB(output0);PW;
+
+START;
+INST0;
+
+setwaitpoint(0);
+setwaittime(0,5);
+INST1;
+
+setstartloop(5);
+setnloop(5,2);
+INST2;
+
+setstartloop(0);
+setnloop(0,2);
+INST3;
+
+INST4;
+
+setstoploop(0);
+setstoploop(5);
+INST5;
+
+INST6;
+
+setwaitpoint(4);
+setwaittime(1,0);
+INST7;
+
+INST8;
+
+setstartloop(2);
+setnloop(2,0);
+INST9;
+
+INST10;
+
+setstoploop(2);
+INST11;
+
+STOP;
+INST12;
+
+
diff --git a/patternGenerator/patterns/test_v2.pat b/patternGenerator/patterns/test_v2.pat
new file mode 100644
index 000000000..b578db88d
--- /dev/null
+++ b/patternGenerator/patterns/test_v2.pat
@@ -0,0 +1,25 @@
+patword 0x0000 0x0000000000000000
+patword 0x0001 0x0000000000000001
+patword 0x0002 0x0000000000000002
+patword 0x0003 0x0000000000000003
+patword 0x0004 0x0000000000000004
+patword 0x0005 0x0000000000000005
+patword 0x0006 0x0000000000000006
+patword 0x0007 0x0000000000000007
+patword 0x0008 0x0000000000000008
+patword 0x0009 0x0000000000000009
+patword 0x000a 0x000000000000000a
+patword 0x000b 0x000000000000000b
+patword 0x000c 0x000000000000000c
+patlimits 0x0000 0x000c
+patioctrl 0x000000000000000f
+patloop 0 0x0003 0x0005
+patnloop 0 2
+patloop 2 0x0009 0x000b
+patnloop 2 0
+patloop 5 0x0002 0x0005
+patnloop 5 2
+patwait 0 0x0001
+patwaittime 0 5
+patwait 4 0x0007
+patwaittime 4 0
diff --git a/patternGenerator/patterns/test_v2.png b/patternGenerator/patterns/test_v2.png
new file mode 100644
index 000000000..3fbf8e6af
Binary files /dev/null and b/patternGenerator/patterns/test_v2.png differ
diff --git a/patternGenerator/plotPattern.py b/patternGenerator/plotPattern.py
new file mode 100755
index 000000000..219bc7b8a
--- /dev/null
+++ b/patternGenerator/plotPattern.py
@@ -0,0 +1,584 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 24 09:44:53 2017
+
+Plot the pattern for New Chip Test Box (.pat)
+
+Changes:
+    - 2017-11-21 Adapt it to python-3
+    - 2017-09-25 All can be plotted
+    - 2017-09-22 Can be plotted but the loop and wait not work yet
+
+@author: zhang_j1
+"""
+import matplotlib.pyplot as plt
+from numpy import *
+from matplotlib.pyplot import *
+from matplotlib.patches import Rectangle
+import os
+
+###############################################################################
+# Input the folder of the pattern file
+Folder = "./patterns/"
+# Prefix name of the .pat and .alias file
+File_pat = "test_v2"
+
+# COLORS AND LINE STYLES
+# alternating colors of the plots (2 needed)
+colors_plot = ['tab:blue', 'tab:orange']
+
+# Wait colors and line styles (6 needed from 0 to 5)
+colors_wait = ['b', 'g', 'r', 'c', 'm', 'y']
+linestyles_wait = ['--', '--', '--', '--', '--', '--']
+alpha_wait = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
+alpha_wait_rect = [0.2, 0.2, 0.2, 0.2, 0.2, 0.2]
+
+# Loop colors and line styles (6 needed from 0 to 5)
+colors_loop = ['tab:green', 'tab:red', 'tab:purple', 'tab:brown', 'tab:ping', 'tab:grey']
+linestyles_loop = ['-.', '-.', '-.', '-.', '-.', '-.']
+alpha_loop = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
+alpha_loop_rect = [0.2, 0.2, 0.2, 0.2, 0.2, 0.2]
+
+# Display the count of clocks
+clock_vertical_lines_spacing = 1
+show_clocks_number = True
+
+# Verbosity
+verbose = False
+###############################################################################
+
+
+# Define a hex to binary function
+# global definition
+# base = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F]
+base = [str(x) for x in range(10)] + [chr(x) for x in range(ord('A'), ord('A')+6)]
+# dec2bin
+
+
+def dec2bin(string_num):
+    num = int(string_num)
+    mid = []
+    while True:
+        if num == 0:
+            break
+        num, rem = divmod(num, 2)
+        mid.append(base[rem])
+ 
+    return ''.join([str(x) for x in mid[::-1]])
+
+
+# dec2binary: better than dec2bin
+def dec2binary(dec_num, width=None):
+    return binary_repr(int(dec_num), width=width)
+
+
+# hex2dec
+def hex2dec(string_num):
+    return str(int(string_num.upper(), 16))
+
+
+# hex2bin
+def hex2bin(string_num):
+    return dec2bin(hex2dec(string_num.upper()))
+
+
+# hex2bin
+def hex2binary(string_num, width=None):
+    return dec2binary(hex2dec(string_num.upper()), width=width)
+
+
+# Look at the alias file and generate the lookup table for pin names
+# Create a 64 bit look up table
+table = []
+for i in range(64):
+    # for special bit
+    if i+1 == 59:
+        table.append([str(i+1), "external_trigger"])
+    elif i+1 == 63:
+        table.append([str(i+1), "adc_enable"])
+    elif i+1 == 62:
+        table.append([str(i+1), "dbit_enable"])
+    else:
+        table.append([str(i+1), ""])
+
+# Loop all lines
+with open(Folder+"/" + File_pat + ".alias") as f:
+    lines = f.readlines()
+f.close()
+
+nlines = len(lines)
+for i in range(nlines):
+    # whether the line is bit definition
+    if lines[i][0:3] == "BIT":
+        # split words
+        words = lines[i].split()
+        bit_num = int(words[0][3:])
+        table[bit_num][0] = words[0][3:]
+        table[bit_num][1] = words[1]
+if verbose:
+    print(table)
+
+
+# Load the pattern and get all lines
+# Loop all lines
+with open(Folder+"/"+File_pat+".pat") as f_pat:
+    lines_pat = f_pat.readlines()
+f_pat.close()
+
+# number of lines for pattern file
+nlines_pat = len(lines_pat)
+# a counter
+cnt = 0
+if verbose:
+    print("The total number of lines of pattern:", nlines_pat)
+# Loop all lines of pattern
+waittime0 = None
+waittime1 = None
+waittime2 = None
+waittime3 = None
+waittime4 = None
+waittime5 = None
+
+nloop0 = None
+nloop1 = None
+nloop2 = None
+nloop3 = None
+nloop4 = None
+nloop5 = None
+
+for k in range(nlines_pat):
+    # content of line
+    words_line = lines_pat[k].split()
+    if words_line[0] == "patword":
+        # print words_line from b0 to b63
+        bits = hex2binary(words_line[-1], 64)[::-1]
+        if verbose:
+            print("The bits for line-", k+1, "is:", bits)
+        # convert string bits to decimal array
+        num_bits = array(list(map(str, bits)), dtype="uint16")
+        if cnt == 0:
+            mat_pat = num_bits
+        else:
+            # add bits to matrix
+            mat_pat = concatenate((mat_pat, num_bits), axis=0)
+        cnt = cnt + 1
+        # print("The matrix of pattern:", mat_pat.reshape(int(cnt), int(len(num_bits))))
+    
+    # Look at the io: 0 for sending to ASIC, 1 for reading from ASIC
+    if words_line[0] == "patioctrl":
+        # print words_line
+        if verbose:
+            print(words_line[-1])
+        bits = hex2binary(words_line[-1], 64)[::-1]
+        if verbose:
+            print(bits)
+        # convert string bits to decimal array
+        out_bits = array(list(map(str, bits)), dtype="uint16")
+    
+    if verbose:
+        print(words_line)
+    # Deal with waiting point
+
+    # ====== WAIT ======
+    if words_line[0] == "patwait" and words_line[1] == "0":
+        wait0 = int(hex2dec(words_line[2]))
+        if verbose:
+            print("wait 0 at:", wait0)
+    if words_line[0] == "patwaittime" and words_line[1] == "0":
+        waittime0 = int(words_line[2])
+        if verbose:
+            print("wait 0 for:", waittime0)
+        
+    if words_line[0] == "patwait" and words_line[1] == "1":
+        wait1 = int(hex2dec(words_line[2]))
+        if verbose:
+            print("wait 1 at:", wait1)
+    if words_line[0] == "patwaittime" and words_line[1] == "1":
+        waittime1 = int(words_line[2])
+        if verbose:
+            print("wait 1 for:", waittime1)
+        
+    if words_line[0] == "patwait" and words_line[1] == "2":
+        wait2 = int(hex2dec(words_line[2]))
+        if verbose:
+            print("wait 2 at:", wait2)
+    if words_line[0] == "patwaittime" and words_line[1] == "2":
+        waittime2 = int(words_line[2])
+        if verbose:
+            print("wait 2 for:", waittime2)
+
+    if words_line[0] == "patwait" and words_line[1] == "3":
+        wait3 = int(hex2dec(words_line[2]))
+        if verbose:
+            print("wait 0 at:", wait3)
+    if words_line[0] == "patwaittime" and words_line[1] == "3":
+        waittime3 = int(words_line[2])
+        if verbose:
+            print("wait 0 for:", waittime3)
+        
+    if words_line[0] == "patwait" and words_line[1] == "4":
+        wait4 = int(hex2dec(words_line[2]))
+        if verbose:
+            print("wait 1 at:", wait4)
+    if words_line[0] == "patwaittime" and words_line[1] == "4":
+        waittime4 = int(words_line[2])
+        if verbose:
+            print("wait 1 for:", waittime4)
+        
+    if words_line[0] == "patwait" and words_line[1] == "5":
+        wait5 = int(hex2dec(words_line[2]))
+        if verbose:
+            print("wait 2 at:", wait5)
+    if words_line[0] == "patwaittime" and words_line[1] == "5":
+        waittime5 = int(words_line[2])
+        if verbose:
+            print("wait 2 for:", waittime5)
+
+    # ====== LOOPS ======
+    if words_line[0] == "patloop" and words_line[1] == "0":
+        loop0_start = int(hex2dec(words_line[2]))
+        loop0_end = int(hex2dec(words_line[3]))
+        if verbose:
+            print("loop 0 start:", loop0_start, ", end:", loop0_end)
+    if words_line[0] == "patnloop" and words_line[1] == "0":
+        nloop0 = int(words_line[2])
+        if verbose:
+            print("loop 0 times:", nloop0)
+
+    if words_line[0] == "patloop" and words_line[1] == "1":
+        loop1_start = int(hex2dec(words_line[2]))
+        loop1_end = int(hex2dec(words_line[3]))
+        if verbose:
+            print("loop 1 start:", loop1_start, ", end:", loop1_end)
+    if words_line[0] == "patnloop" and words_line[1] == "1":
+        nloop1 = int(words_line[2])
+        if verbose:
+            print("loop 1 times:", nloop1)
+
+    if words_line[0] == "patloop" and words_line[1] == "2":
+        loop2_start = int(hex2dec(words_line[2]))
+        loop2_end = int(hex2dec(words_line[3]))
+        if verbose:
+            print("loop 2 start:", loop2_start, ", end:", loop2_end)
+    if words_line[0] == "patnloop" and words_line[1] == "2":
+        nloop2 = int(words_line[2])
+        if verbose:
+            print("loop 2 times:", nloop2)
+    
+    if words_line[0] == "patloop" and words_line[1] == "3":
+        loop3_start = int(hex2dec(words_line[2]))
+        loop3_end = int(hex2dec(words_line[3]))
+        if verbose:
+            print("loop 3 start:", loop3_start, ", end:", loop3_end)
+    if words_line[0] == "patnloop" and words_line[1] == "3":
+        nloop3 = int(words_line[2])
+        if verbose:
+            print("loop 3 times:", nloop3)
+
+    if words_line[0] == "patloop" and words_line[1] == "4":
+        loop4_start = int(hex2dec(words_line[2]))
+        loop4_end = int(hex2dec(words_line[3]))
+        if verbose:
+            print("loop 4 start:", loop4_start, ", end:", loop4_end)
+    if words_line[0] == "patnloop" and words_line[1] == "4":
+        nloop4 = int(words_line[2])
+        if verbose:
+            print("loop 4 times:", nloop4)
+
+    if words_line[0] == "patloop" and words_line[1] == "5":
+        loop5_start = int(hex2dec(words_line[2]))
+        loop5_end = int(hex2dec(words_line[3]))
+        if verbose:
+            print("loop 5 start:", loop5_start, ", end:", loop5_end)
+    if words_line[0] == "patnloop" and words_line[1] == "5":
+        nloop5 = int(words_line[2])
+        if verbose:
+            print("loop 5 times:", nloop5)
+# print(out_bits)
+
+# internal counter
+avail_index = []
+avail_name = []
+# Remove non-used bits
+for i in range(64):
+    # if out_bits[0][i] == 1:
+    if out_bits[i] == 1:
+        avail_index.append(i)
+        avail_name.append(table[i][1])
+if verbose:
+    print(avail_index)
+    print(avail_name)
+
+# number of effective used bits
+nbiteff = len(avail_name)
+
+# subMat = mat_ext[:,index]
+# print(mat_pat.shape)
+subMat = mat_pat.reshape(int(cnt), int(len(num_bits)))[0:, avail_index]
+# subMat = mat_pat[avail_index]
+timing = linspace(0, subMat.shape[0]-1, subMat.shape[0])
+rcParams['figure.figsize'] = 15, 5
+
+
+# ============= PLOTTING =============
+
+rcParams["font.weight"] = "bold"
+rcParams["axes.labelweight"] = "bold"
+fig2, axs2 = subplots(nbiteff, sharex='all')
+subplots_adjust(wspace=0, hspace=0)
+# axs2[nbiteff - 1].set(xlabel='Timing [clk]')
+for idx, i in enumerate(range(nbiteff)):
+
+    axs2[idx].plot(subMat.T[i], "-", drawstyle="steps-post", linewidth=2.0, color=colors_plot[idx % 2])
+    x_additional = range(len(subMat.T[i]) - 1, len(subMat.T[i]) + 2)
+    additional_stuff = [subMat.T[i][-1]] * 3
+
+    axs2[idx].plot(x_additional, additional_stuff,
+                   "--", drawstyle="steps-post", linewidth=2.0, color=colors_plot[idx % 2], alpha=0.5)
+    axs2[idx].yaxis.set_ticks([0.5], minor=False)
+    axs2[idx].xaxis.set_ticks(arange(0, len(subMat.T[i]) + 10, clock_vertical_lines_spacing))
+
+    axs2[idx].yaxis.set_ticklabels([avail_name[i]])
+    axs2[idx].get_yticklabels()[0].set_color(colors_plot[idx % 2])
+
+    axs2[idx].grid(1, 'both', 'both', alpha=0.5)
+    axs2[idx].yaxis.grid(which="both", color=colors_plot[idx % 2], alpha=0.2)
+    if idx != nbiteff - 1:
+        if not show_clocks_number:
+            axs2[idx].xaxis.set_ticklabels([])
+        axs2[idx].set(xlabel=' ', ylim=(-0.2, 1.2))
+    else:
+        axs2[idx].set(xlabel='Timing [clk]', ylim=(-0.2, 1.2))
+    # axs2[idx].set_xlim(left=0)
+    axs2[idx].set_xlim(left=0, right=len(subMat.T[i]) + 1)
+    axs2[idx].spines['top'].set_visible(False)
+    axs2[idx].spines['right'].set_alpha(0.2)
+    axs2[idx].spines['right'].set_visible(True)
+    axs2[idx].spines['bottom'].set_visible(False)
+    axs2[idx].spines['left'].set_visible(False)
+
+    # =====================================================================================================
+    # Plot the wait lines
+    # Wait 0
+    if waittime0 is not None:
+        if waittime0 == 0:
+            axs2[idx].plot([wait0, wait0], [-10, 10],
+                           linestyle=linestyles_wait[0], color=colors_wait[0], alpha=alpha_wait[0], linewidth=2.0)
+            axs2[idx].plot([wait0 + 1, wait0 + 1], [-10, 10],
+                           linestyle=linestyles_wait[0], color=colors_wait[0], linewidth=2.0, alpha=alpha_wait[0])
+            axs2[idx].add_patch(Rectangle((wait0, -10), 1, 20,
+                                          label="wait 0: skipped" if idx == 0 else "",
+                                          facecolor=colors_wait[0], alpha=alpha_wait_rect[0], hatch='\\\\'))
+        else:
+            axs2[idx].plot([wait0, wait0], [-10, 10],
+                           linestyle=linestyles_wait[0], color=colors_wait[0],
+                           label="wait 0: " + str(waittime0) + " clk" if idx == 0 else "",
+                           linewidth=2.0, alpha=alpha_wait[0])
+
+    # Wait 1
+    if waittime1 is not None:
+        if waittime1 == 0:
+            axs2[idx].plot([wait1, wait1], [-10, 10],
+                           linestyle=linestyles_wait[1], color=colors_wait[1], alpha=alpha_wait[1], linewidth=2.0)
+            axs2[idx].plot([wait1 + 1, wait1 + 1], [-10, 10],
+                           linestyle=linestyles_wait[1], color=colors_wait[1], linewidth=2.0, alpha=alpha_wait[1])
+            axs2[idx].add_patch(Rectangle((wait1, -10), 1, 20,
+                                          label="wait 1: skipped" if idx == 0 else "",
+                                          facecolor=colors_wait[1], alpha=alpha_wait_rect[1], hatch='\\\\'))
+        else:
+            axs2[idx].plot([wait1, wait1], [-10, 10],
+                           linestyle=linestyles_wait[1], color=colors_wait[1],
+                           label="wait 1: " + str(waittime1) + " clk" if idx == 0 else "",
+                           linewidth=2.0, alpha=alpha_wait[1])
+
+    # Wait 2
+    if waittime2 is not None:
+        if waittime2 == 0:
+            axs2[idx].plot([wait2, wait2], [-10, 10],
+                           linestyle=linestyles_wait[2], color=colors_wait[2], alpha=alpha_wait[2], linewidth=2.0)
+            axs2[idx].plot([wait2 + 1, wait2 + 1], [-10, 10],
+                           linestyle=linestyles_wait[2], color=colors_wait[2], linewidth=2.0, alpha=alpha_wait[2])
+            axs2[idx].add_patch(Rectangle((wait2, -10), 1, 20,
+                                          label="wait 2: skipped" if idx == 0 else "",
+                                          facecolor=colors_wait[2], alpha=alpha_wait_rect[2], hatch='\\\\'))
+        else:
+            axs2[idx].plot([wait2, wait2], [-10, 10],
+                           linestyle=linestyles_wait[2], color=colors_wait[2],
+                           label="wait 2: " + str(waittime2) + " clk" if idx == 0 else "",
+                           linewidth=2.0, alpha=alpha_wait[2])
+
+    # Wait 3
+    if waittime3 is not None:
+        if waittime3 == 0:
+            axs2[idx].plot([wait3, wait3], [-10, 10],
+                           linestyle=linestyles_wait[3], color=colors_wait[3], alpha=alpha_wait[3], linewidth=2.0)
+            axs2[idx].plot([wait3 + 1, wait3 + 1], [-10, 10],
+                           linestyle=linestyles_wait[3], color=colors_wait[3], linewidth=2.0, alpha=alpha_wait[3])
+            axs2[idx].add_patch(Rectangle((wait3, -10), 1, 20,
+                                          label="wait 3: skipped" if idx == 0 else "",
+                                          facecolor=colors_wait[3], alpha=alpha_wait_rect[3], hatch='\\\\'))
+        else:
+            axs2[idx].plot([wait3, wait3], [-10, 10],
+                           linestyle=linestyles_wait[3], color=colors_wait[3],
+                           label="wait 3: " + str(waittime3) + " clk" if idx == 0 else "",
+                           linewidth=2.0, alpha=alpha_wait[3])
+
+    # Wait 4
+    if waittime4 is not None:
+        if waittime4 == 0:
+            axs2[idx].plot([wait4, wait4], [-10, 10],
+                           linestyle=linestyles_wait[4], color=colors_wait[4], alpha=alpha_wait[4], linewidth=2.0)
+            axs2[idx].plot([wait4 + 1, wait4 + 1], [-10, 10],
+                           linestyle=linestyles_wait[4], color=colors_wait[4], linewidth=2.0, alpha=alpha_wait[4])
+            axs2[idx].add_patch(Rectangle((wait4, -10), 1, 20,
+                                          label="wait 4: skipped" if idx == 0 else "",
+                                          facecolor=colors_wait[4], alpha=alpha_wait_rect[4], hatch='\\\\'))
+        else:
+            axs2[idx].plot([wait4, wait4], [-10, 10],
+                           linestyle=linestyles_wait[4], color=colors_wait[4],
+                           label="wait 4: " + str(waittime4) + " clk" if idx == 0 else "",
+                           linewidth=2.0, alpha=alpha_wait[4])
+
+    # Wait 5
+    if waittime5 is not None:
+        if waittime5 == 0:
+            axs2[idx].plot([wait5, wait5], [-10, 10],
+                           linestyle=linestyles_wait[5], color=colors_wait[5], alpha=alpha_wait[5], linewidth=2.0)
+            axs2[idx].plot([wait5 + 1, wait5 + 1], [-10, 10],
+                           linestyle=linestyles_wait[5], color=colors_wait[5], linewidth=2.0, alpha=alpha_wait[5])
+            axs2[idx].add_patch(Rectangle((wait5, -10), 1, 20,
+                                          label="wait 5: skipped" if idx == 0 else "",
+                                          facecolor=colors_wait[5], alpha=alpha_wait_rect[5], hatch='\\\\'))
+        else:
+            axs2[idx].plot([wait5, wait5], [-10, 10],
+                           linestyle=linestyles_wait[5], color=colors_wait[5],
+                           label="wait 5: " + str(waittime5) + " clk" if idx == 0 else "",
+                           linewidth=2.0, alpha=alpha_wait[5])
+
+    # =====================================================================================================
+    # Plot the loop lines
+    # Loop 0
+    if nloop0 is not None:
+        if nloop0 == 0:
+            axs2[idx].plot([loop0_start, loop0_start], [-10, 10],
+                           linestyle=linestyles_loop[0], color=colors_loop[0],
+                           alpha=alpha_loop[0], linewidth=2.0)
+            axs2[idx].plot([loop0_end + 1, loop0_end + 1], [-10, 10],
+                           linestyle=linestyles_loop[0], color=colors_loop[0], alpha=alpha_loop[0], linewidth=2.0)
+            axs2[idx].add_patch(Rectangle((loop0_start, -10), loop0_end + 1 - loop0_start, 20,
+                                          label="loop 0: skipped" if idx == 0 else "",
+                                          facecolor=colors_loop[0], alpha=alpha_loop_rect[0], hatch='//'))
+        else:
+            axs2[idx].plot([loop0_start, loop0_start], [-10, 10],
+                           linestyle=linestyles_loop[0], color=colors_loop[0], alpha=alpha_loop[0],
+                           label="loop 0: " + str(nloop0) + " times" if idx == 0 else "", linewidth=2.0)
+            axs2[idx].plot([loop0_end, loop0_end], [-10, 10],
+                           linestyle=linestyles_loop[0], color=colors_loop[0], alpha=alpha_loop[0], linewidth=2.0)
+
+    # Loop 1
+    if nloop1 is not None:
+        if nloop1 == 0:
+            axs2[idx].plot([loop1_start, loop1_start], [-10, 10],
+                           linestyle=linestyles_loop[1], color=colors_loop[1],
+                           alpha=alpha_loop[1], linewidth=2.0)
+            axs2[idx].plot([loop1_end + 1, loop1_end + 1], [-10, 10],
+                           linestyle=linestyles_loop[1], color=colors_loop[1], alpha=alpha_loop[1], linewidth=2.0)
+            axs2[idx].add_patch(Rectangle((loop1_start, -10), loop1_end + 1 - loop1_start, 20,
+                                          label="loop 1: skipped" if idx == 0 else "",
+                                          facecolor=colors_loop[1], alpha=alpha_loop_rect[1], hatch='//'))
+        else:
+            axs2[idx].plot([loop1_start, loop1_start], [-10, 10],
+                           linestyle=linestyles_loop[1], color=colors_loop[1], alpha=alpha_loop[1],
+                           label="loop 1: " + str(nloop1) + " times" if idx == 0 else "", linewidth=2.0)
+            axs2[idx].plot([loop1_end, loop1_end], [-10, 10],
+                           linestyle=linestyles_loop[1], color=colors_loop[1], alpha=alpha_loop[1], linewidth=2.0)
+
+    # Loop 2
+    if nloop2 is not None:
+        if nloop2 == 0:
+            axs2[idx].plot([loop2_start, loop2_start], [-10, 10],
+                           linestyle=linestyles_loop[2], color=colors_loop[2],
+                           alpha=alpha_loop[2], linewidth=2.0)
+            axs2[idx].plot([loop2_end + 1, loop2_end + 1], [-10, 10],
+                           linestyle=linestyles_loop[2], color=colors_loop[2], alpha=alpha_loop[2], linewidth=2.0)
+            axs2[idx].add_patch(Rectangle((loop2_start, -10), loop2_end + 1 - loop2_start, 20,
+                                          label="loop 2: skipped" if idx == 0 else "",
+                                          facecolor=colors_loop[2], alpha=alpha_loop_rect[2], hatch='//'))
+        else:
+            axs2[idx].plot([loop2_start, loop2_start], [-10, 10],
+                           linestyle=linestyles_loop[2], color=colors_loop[2], alpha=alpha_loop[2],
+                           label="loop 2: " + str(nloop2) + " times" if idx == 0 else "", linewidth=2.0)
+            axs2[idx].plot([loop2_end, loop2_end], [-10, 10],
+                           linestyle=linestyles_loop[0], color=colors_loop[0], alpha=alpha_loop[2], linewidth=2.0)
+
+    # Loop 3
+    if nloop3 is not None:
+        if nloop3 == 0:
+            axs2[idx].plot([loop3_start, loop3_start], [-10, 10],
+                           linestyle=linestyles_loop[3], color=colors_loop[3],
+                           alpha=alpha_loop[3], linewidth=2.0)
+            axs2[idx].plot([loop3_end + 1, loop3_end + 1], [-10, 10],
+                           linestyle=linestyles_loop[3], color=colors_loop[3], alpha=alpha_loop[3], linewidth=2.0)
+            axs2[idx].add_patch(Rectangle((loop3_start, -10), loop3_end + 1 - loop3_start, 20,
+                                          label="loop 3: skipped" if idx == 0 else "",
+                                          facecolor=colors_loop[3], alpha=alpha_loop_rect[3], hatch='//'))
+        else:
+            axs2[idx].plot([loop3_start, loop3_start], [-10, 10],
+                           linestyle=linestyles_loop[3], color=colors_loop[3], alpha=alpha_loop[3],
+                           label="loop 3: " + str(nloop3) + " times" if idx == 0 else "", linewidth=2.0)
+            axs2[idx].plot([loop3_end, loop3_end], [-10, 10],
+                           linestyle=linestyles_loop[3], color=colors_loop[3], alpha=alpha_loop[3], linewidth=2.0)
+
+    # Loop 4
+    if nloop4 is not None:
+        if nloop4 == 0:
+            axs2[idx].plot([loop4_start, loop4_start], [-10, 10],
+                           linestyle=linestyles_loop[4], color=colors_loop[4],
+                           alpha=alpha_loop[4], linewidth=2.0)
+            axs2[idx].plot([loop4_end + 1, loop4_end + 1], [-10, 10],
+                           linestyle=linestyles_loop[4], color=colors_loop[4], alpha=alpha_loop[4], linewidth=2.0)
+            axs2[idx].add_patch(Rectangle((loop4_start, -10), loop4_end + 1 - loop4_start, 20,
+                                          label="loop 4: skipped" if idx == 0 else "",
+                                          facecolor=colors_loop[4], alpha=alpha_loop_rect[4], hatch='//'))
+        else:
+            axs2[idx].plot([loop4_start, loop4_start], [-10, 10],
+                           linestyle=linestyles_loop[4], color=colors_loop[4], alpha=alpha_loop[4],
+                           label="loop 4: " + str(nloop4) + " times" if idx == 0 else "", linewidth=2.0)
+            axs2[idx].plot([loop4_end, loop4_end], [-10, 10],
+                           linestyle=linestyles_loop[4], color=colors_loop[4], alpha=alpha_loop[4], linewidth=2.0)
+
+    # Loop 5
+    if nloop5 is not None:
+        if nloop5 == 0:
+            axs2[idx].plot([loop5_start, loop5_start], [-10, 10],
+                           linestyle=linestyles_loop[5], color=colors_loop[5],
+                           alpha=alpha_loop[5], linewidth=2.0)
+            axs2[idx].plot([loop5_end + 1, loop5_end + 1], [-10, 10],
+                           linestyle=linestyles_loop[5], color=colors_loop[5], alpha=alpha_loop[5], linewidth=2.0)
+            axs2[idx].add_patch(Rectangle((loop5_start, -10), loop5_end + 1 - loop5_start, 20,
+                                          label="loop 5: skipped" if idx == 0 else "",
+                                          facecolor=colors_loop[5], alpha=alpha_loop_rect[5], hatch='//'))
+        else:
+            axs2[idx].plot([loop5_start, loop5_start], [-10, 10],
+                           linestyle=linestyles_loop[5], color=colors_loop[5], alpha=alpha_loop[5],
+                           label="loop 5: " + str(nloop5) + " times" if idx == 0 else "", linewidth=2.0)
+            axs2[idx].plot([loop5_end, loop5_end], [-10, 10],
+                           linestyle=linestyles_loop[5], color=colors_loop[5], alpha=alpha_loop[5], linewidth=2.0)
+
+
+n_cols = count_nonzero([waittime0 != 0, waittime1 != 0, waittime2 != 0, waittime3 != 0, waittime4 != 0, waittime5 != 0,
+                        nloop0 != 0, nloop1 != 0, nloop2 != 0, nloop3 != 0, nloop4 != 0, nloop5 != 0])
+fig2.legend(loc="upper center", ncol=n_cols)
+# manager = get_current_fig_manager()
+# manager.window.showMaximized()
+
+figure = plt.gcf()  # get current figure
+figure.set_size_inches(20, 10)
+# when saving, specify the DPI
+# tight_layout()
+plt.savefig(Folder+"/"+File_pat+".png", dpi=300)
+
+# Remove the white space around the plot -- only works on Unix (ImageMagick command)
+os.system(f'mogrify -trim {Folder}/{File_pat}.png')
+
+show()