diff --git a/FakeFileCreator/FakeFileCreator.csproj b/FakeFileCreator/FakeFileCreator.csproj
index c6d00c5..98df7a1 100644
--- a/FakeFileCreator/FakeFileCreator.csproj
+++ b/FakeFileCreator/FakeFileCreator.csproj
@@ -5,7 +5,7 @@
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{7609DDC1-DBBD-4C63-ADE6-E123C07E0A90}</ProjectGuid>
-    <OutputType>Exe</OutputType>
+    <OutputType>WinExe</OutputType>
     <RootNamespace>FakeFileCreator</RootNamespace>
     <AssemblyName>FakeFileCreator</AssemblyName>
     <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
diff --git a/FakeFileCreator/MainForm.Designer.cs b/FakeFileCreator/MainForm.Designer.cs
index 7c742ee..9c4840d 100644
--- a/FakeFileCreator/MainForm.Designer.cs
+++ b/FakeFileCreator/MainForm.Designer.cs
@@ -33,6 +33,13 @@ private void InitializeComponent()
             this.btnPictures = new System.Windows.Forms.Button();
             this.btnVideos = new System.Windows.Forms.Button();
             this.btnMusic = new System.Windows.Forms.Button();
+            this.progressBar = new System.Windows.Forms.ProgressBar();
+            this.sidepanel = new System.Windows.Forms.Panel();
+            this.filestogenerateTextbox = new System.Windows.Forms.TextBox();
+            this.ftogeneratelable = new System.Windows.Forms.Label();
+            this.filesprocessedlabel = new System.Windows.Forms.Label();
+            this.populate_drive = new System.Windows.Forms.Button();
+            this.sidepanel.SuspendLayout();
             this.SuspendLayout();
             // 
             // btnDocuments
@@ -53,6 +60,7 @@ private void InitializeComponent()
             this.btnPictures.TabIndex = 1;
             this.btnPictures.Text = "Create Fake Pictures";
             this.btnPictures.UseVisualStyleBackColor = true;
+            this.btnPictures.Click += new System.EventHandler(this.btnPictures_Click);
             // 
             // btnVideos
             // 
@@ -71,12 +79,72 @@ private void InitializeComponent()
             this.btnMusic.TabIndex = 3;
             this.btnMusic.Text = "Create Fake Music";
             this.btnMusic.UseVisualStyleBackColor = true;
+            this.btnMusic.Click += new System.EventHandler(this.btnMusic_Click);
+            // 
+            // progressBar
+            // 
+            this.progressBar.Location = new System.Drawing.Point(12, 143);
+            this.progressBar.Name = "progressBar";
+            this.progressBar.Size = new System.Drawing.Size(317, 10);
+            this.progressBar.TabIndex = 4;
+            // 
+            // sidepanel
+            // 
+            this.sidepanel.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
+            this.sidepanel.Controls.Add(this.filestogenerateTextbox);
+            this.sidepanel.Controls.Add(this.ftogeneratelable);
+            this.sidepanel.Location = new System.Drawing.Point(230, 12);
+            this.sidepanel.Name = "sidepanel";
+            this.sidepanel.Size = new System.Drawing.Size(99, 59);
+            this.sidepanel.TabIndex = 5;
+            // 
+            // filestogenerateTextbox
+            // 
+            this.filestogenerateTextbox.Location = new System.Drawing.Point(7, 27);
+            this.filestogenerateTextbox.Name = "filestogenerateTextbox";
+            this.filestogenerateTextbox.Size = new System.Drawing.Size(83, 20);
+            this.filestogenerateTextbox.TabIndex = 1;
+            this.filestogenerateTextbox.Text = "50";
+            this.filestogenerateTextbox.TextChanged += new System.EventHandler(this.filestogenerateTextbox_TextChanged);
+            // 
+            // ftogeneratelable
+            // 
+            this.ftogeneratelable.AutoSize = true;
+            this.ftogeneratelable.Location = new System.Drawing.Point(6, 8);
+            this.ftogeneratelable.Name = "ftogeneratelable";
+            this.ftogeneratelable.Size = new System.Drawing.Size(85, 13);
+            this.ftogeneratelable.TabIndex = 0;
+            this.ftogeneratelable.Text = "Files to generate";
+            // 
+            // filesprocessedlabel
+            // 
+            this.filesprocessedlabel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.filesprocessedlabel.AutoSize = true;
+            this.filesprocessedlabel.Location = new System.Drawing.Point(12, 127);
+            this.filesprocessedlabel.Name = "filesprocessedlabel";
+            this.filesprocessedlabel.Size = new System.Drawing.Size(0, 13);
+            this.filesprocessedlabel.TabIndex = 6;
+            this.filesprocessedlabel.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
+            // 
+            // populate_drive
+            // 
+            this.populate_drive.Location = new System.Drawing.Point(230, 70);
+            this.populate_drive.Name = "populate_drive";
+            this.populate_drive.Size = new System.Drawing.Size(99, 23);
+            this.populate_drive.TabIndex = 7;
+            this.populate_drive.Text = "Populate Drive";
+            this.populate_drive.UseVisualStyleBackColor = true;
+            this.populate_drive.Click += new System.EventHandler(this.populate_drive_Click);
             // 
             // MainForm
             // 
             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.ClientSize = new System.Drawing.Size(234, 138);
+            this.ClientSize = new System.Drawing.Size(334, 158);
+            this.Controls.Add(this.populate_drive);
+            this.Controls.Add(this.filesprocessedlabel);
+            this.Controls.Add(this.sidepanel);
+            this.Controls.Add(this.progressBar);
             this.Controls.Add(this.btnMusic);
             this.Controls.Add(this.btnVideos);
             this.Controls.Add(this.btnPictures);
@@ -84,7 +152,11 @@ private void InitializeComponent()
             this.Name = "MainForm";
             this.ShowIcon = false;
             this.Text = "FakeFileCreator";
+            this.Load += new System.EventHandler(this.MainForm_Load);
+            this.sidepanel.ResumeLayout(false);
+            this.sidepanel.PerformLayout();
             this.ResumeLayout(false);
+            this.PerformLayout();
 
         }
 
@@ -94,6 +166,12 @@ private void InitializeComponent()
         private System.Windows.Forms.Button btnPictures;
         private System.Windows.Forms.Button btnVideos;
         private System.Windows.Forms.Button btnMusic;
+        private System.Windows.Forms.ProgressBar progressBar;
+        private System.Windows.Forms.Panel sidepanel;
+        private System.Windows.Forms.TextBox filestogenerateTextbox;
+        private System.Windows.Forms.Label ftogeneratelable;
+        private System.Windows.Forms.Label filesprocessedlabel;
+        private System.Windows.Forms.Button populate_drive;
     }
 }
 
diff --git a/FakeFileCreator/MainForm.cs b/FakeFileCreator/MainForm.cs
index 8a8ee99..c097d72 100644
--- a/FakeFileCreator/MainForm.cs
+++ b/FakeFileCreator/MainForm.cs
@@ -1,12 +1,9 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.ComponentModel;
-using System.Data;
-using System.Drawing;
 using System.IO;
 using System.Linq;
 using System.Net;
-using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 
@@ -15,67 +12,329 @@ namespace FakeFileCreator
     public partial class MainForm : Form
     {
         private Random rand = new Random();
+        private List<string> cachedWords = new List<string>();
         private static string EnglishWordListURL = @"https://raw.githubusercontent.com/dwyl/english-words/master/words_alpha.txt";
+        private string tempWordFile;
 
         public MainForm()
         {
             InitializeComponent();
+            tempWordFile = Path.Combine(Path.GetTempPath(), "words.txt");
+            Load += MainForm_Load;
         }
 
-        private void btnDocuments_Click(object sender, EventArgs e)
+        private async void MainForm_Load(object sender, EventArgs e)
         {
-            List<string> extensions = new List<string> { ".txt", ".docx", ".pdf", ".xls", ".xlxs", ".ppt", ".pptx", ".odt" };
+            await DownloadAndCacheWordListAsync();
+        }
+
+        private async Task DownloadAndCacheWordListAsync()
+        {
+            progressBar.Invoke((Action)(() =>
+            {
+                progressBar.Value = 0;
+                progressBar.Maximum = 100;
+            }));
 
-            Console.WriteLine("Looking for words.txt...");
-            if (!File.Exists("words.txt"))
+            if (!File.Exists(tempWordFile))
             {
-                var client = new WebClient();
-                Console.WriteLine("Getting words from github...");
-                string data = client.DownloadString(EnglishWordListURL);
-                using (StreamWriter sw = new StreamWriter("words.txt")) { sw.Write(data); }
+                using (var client = new WebClient())
+                {
+                    client.DownloadProgressChanged += (s, e) =>
+                    {
+                        progressBar.Invoke((Action)(() =>
+                        {
+                            progressBar.Value = e.ProgressPercentage;
+                        }));
+                    };
+
+                    await client.DownloadFileTaskAsync(EnglishWordListURL, tempWordFile);
+                }
             }
 
-            List<string> words = new List<string>();
-            using (StreamReader sr = new StreamReader("words.txt"))
+            while (true)
             {
-                while (!sr.EndOfStream)
+                try
+                {
+                    using (FileStream fs = File.Open(tempWordFile, FileMode.Open, FileAccess.Read, FileShare.Read))
+                    using (StreamReader sr = new StreamReader(fs))
+                    {
+                        cachedWords = sr.ReadToEnd().Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries)
+                                       .Where(l => l.Length > 2 && l.Length < 14)
+                                       .ToList();
+                    }
+                    break;
+                }
+                catch (IOException)
                 {
-                    words.Add(sr.ReadLine());
+                    await Task.Delay(100);
                 }
             }
 
-            Console.WriteLine("Words count: " + words.Count);
+            progressBar.Invoke((Action)(() => progressBar.Value = 0));
+        }
+
+        private int GetFileCount()
+        {
+            if (string.IsNullOrWhiteSpace(filestogenerateTextbox.Text))
+            {
+                MessageBox.Show("Enter a number of files to generate");
+                return -1;
+            }
+
+            if (int.TryParse(filestogenerateTextbox.Text, out int v))
+                return v;
+
+            MessageBox.Show("Invalid number");
+            return -1;
+        }
+
+        private string GenerateRandomFilename(List<string> extensions)
+        {
+            int wordsLong = rand.Next(2, 5);
+            string[] w = new string[wordsLong];
+            for (int i = 0; i < wordsLong; i++)
+                w[i] = cachedWords[rand.Next(cachedWords.Count)];
+
+            return string.Join("_", w) + extensions[rand.Next(extensions.Count)];
+        }
+
+        private string GenerateRandomFolderName()
+        {
+            int wordsLong = rand.Next(1, 3);
+            string[] w = new string[wordsLong];
+            for (int i = 0; i < wordsLong; i++)
+                w[i] = cachedWords[rand.Next(cachedWords.Count)];
+
+            return string.Join(" ", w);
+        }
+
+        private void GenerateBinaryFile(string path, int size)
+        {
+            byte[] data = new byte[size];
+            rand.NextBytes(data);
+            File.WriteAllBytes(path, data);
+        }
+
+        private async Task GenerateFilesAsync(string rootFolder, List<string> extensions, int count)
+        {
+            if (cachedWords.Count == 0)
+                await DownloadAndCacheWordListAsync();
+
+            Directory.CreateDirectory(rootFolder);
 
-            if(words.Count == 0) return;
-            if(extensions.Count == 0) return;
+            progressBar.Invoke((Action)(() =>
+            {
+                progressBar.Value = 0;
+                progressBar.Maximum = count;
+            }));
 
-            int filesToGenerate = rand.Next(10, 50);
-            Console.WriteLine($"Generating [{filesToGenerate}] files...");
-            for (int i = 0; i < filesToGenerate; i++)
+            filesprocessedlabel.Invoke((Action)(() =>
             {
-                string filename = "";
-                int wordsLong = rand.Next(1, 4);
-                for (int j = 0; j < wordsLong; j++)
+                filesprocessedlabel.Text = $"0 / {count}";
+            }));
+
+            int maxThreads = Math.Max(Environment.ProcessorCount - 2, 1);
+            var completedCount = 0;
+
+            List<string> folders = new List<string> { rootFolder };
+
+            int folderCount = Math.Max(1, count / 10);
+            for (int i = 0; i < folderCount; i++)
+            {
+                string parent = folders[rand.Next(folders.Count)];
+                string folderPath = Path.Combine(parent, GenerateRandomFolderName());
+                Directory.CreateDirectory(folderPath);
+                folders.Add(folderPath);
+            }
+
+            await Task.Run(() =>
+            {
+                ParallelOptions options = new ParallelOptions { MaxDegreeOfParallelism = maxThreads };
+
+                while (completedCount < count)
                 {
-                    int wordToGet = rand.Next(0, words.Count);
-                    Console.WriteLine("Word to get: " + wordToGet);
-                    filename += words[wordToGet] + " ";
+                    Parallel.For(0, count - completedCount, options, _ =>
+                    {
+                        string folder = folders[rand.Next(folders.Count)];
+
+                        string filename = GenerateRandomFilename(extensions);
+                        string path = Path.Combine(folder, filename);
+
+                        bool created = false;
+                        lock (rand)
+                        {
+                            if (!File.Exists(path))
+                            {
+                                GenerateBinaryFile(path, rand.Next(50000, 8000000));
+                                created = true;
+                            }
+                        }
+
+                        if (created)
+                        {
+                            int progress = System.Threading.Interlocked.Increment(ref completedCount);
+                            progressBar.Invoke((Action)(() => progressBar.Value = progress));
+                            filesprocessedlabel.Invoke((Action)(() =>
+                                filesprocessedlabel.Text = $"{progress} / {count}"
+                            ));
+                        }
+                    });
                 }
-                filename += extensions[rand.Next(0, extensions.Count)];
+            });
+        }
 
-                Console.WriteLine($"Filename: {filename}");
+        private async void btnDocuments_Click(object sender, EventArgs e)
+        {
+            int count = GetFileCount();
+            if (count <= 0) return;
 
-                string myDocs = Path.Combine(Environment.ExpandEnvironmentVariables("%userprofile%"), "Documents");
-                FileInfo fInf = new FileInfo(myDocs + "/" + filename);
-                if (fInf.Exists) continue;
+            var ext = new List<string> { ".txt", ".docx", ".pdf", ".xls", ".xlsx", ".ppt", ".pptx", ".odt", ".rtf" };
+            string folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "FakeDocs");
 
-                fInf.Create().Close();
+            await GenerateFilesAsync(folder, ext, count);
+            MessageBox.Show($"Created {count} fake documents");
+        }
 
-                StreamWriter sw = new StreamWriter(fInf.OpenWrite());
-                sw.Write("NULL_NULL_NULL");
-                sw.Flush();
-                sw.Close();
+        private async void btnPictures_Click(object sender, EventArgs e)
+        {
+            int count = GetFileCount();
+            if (count <= 0) return;
+
+            var ext = new List<string> { ".png", ".jpg", ".jpeg" };
+            string folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures), "FakePics");
+
+            await GenerateFilesAsync(folder, ext, count);
+            MessageBox.Show($"Created {count} fake pictures");
+        }
+
+        private async void btnVideos_Click(object sender, EventArgs e)
+        {
+            int count = GetFileCount();
+            if (count <= 0) return;
+
+            var ext = new List<string> { ".mp4", ".mov", ".avi", ".mkv" };
+            string folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), "FakeVideos");
+
+            await GenerateFilesAsync(folder, ext, count);
+            MessageBox.Show($"Created {count} fake videos");
+        }
+
+        private async void btnMusic_Click(object sender, EventArgs e)
+        {
+            int count = GetFileCount();
+            if (count <= 0) return;
+
+            var ext = new List<string> { ".mp3", ".wav", ".flac" };
+            string folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyMusic), "FakeMusic");
+
+            await GenerateFilesAsync(folder, ext, count);
+            MessageBox.Show($"Created {count} fake music files");
+        }
+
+        private void filestogenerateTextbox_TextChanged(object sender, EventArgs e)
+        {
+            string t = filestogenerateTextbox.Text;
+            string filtered = new string(t.Where(char.IsDigit).ToArray());
+            if (t != filtered)
+            {
+                int pos = filestogenerateTextbox.SelectionStart;
+                filestogenerateTextbox.Text = filtered;
+                filestogenerateTextbox.SelectionStart = Math.Min(pos, filtered.Length);
+            }
+        }
+
+        private async void populate_drive_Click(object sender, EventArgs e)
+        {
+            using (var fbd = new FolderBrowserDialog())
+            {
+                fbd.Description = "Select a drive/folder to fill (C: is blocked)";
+                if (fbd.ShowDialog() != DialogResult.OK) return;
+
+                string rootPath = fbd.SelectedPath;
+                if (Path.GetPathRoot(rootPath).ToUpper() == @"C:\")
+                {
+                    MessageBox.Show("Populating C: drive is blocked for safety. Choose another drive.");
+                    return;
+                }
+
+                var driveInfo = new DriveInfo(rootPath);
+                long totalSize = driveInfo.TotalSize;
+                long targetFreeSpace = (long)(totalSize * 0.1);
+                long currentFreeSpace = driveInfo.AvailableFreeSpace;
+
+                if (MessageBox.Show($"Are you sure you want to fill {rootPath}? This will fill until ~90% of the drive is used!", "Confirm", MessageBoxButtons.YesNo) != DialogResult.Yes)
+                    return;
+
+                List<(string type, List<string> extensions)> fileTypes = new List<(string, List<string>)>
+        {
+            ("Documents", new List<string> { ".txt", ".docx", ".pdf", ".xls", ".xlsx", ".ppt", ".pptx", ".odt", ".rtf" }),
+            ("Pictures", new List<string> { ".png", ".jpg", ".jpeg" }),
+            ("Videos", new List<string> { ".mp4", ".mov", ".avi", ".mkv" }),
+            ("Music", new List<string> { ".mp3", ".wav", ".flac" })
+        };
+
+                await DownloadAndCacheWordListAsync();
+
+                int maxThreads = Math.Max(Environment.ProcessorCount * 2, 4);
+                var folders = new List<string> { rootPath };
+
+                await Task.Run(() =>
+                {
+                    ParallelOptions options = new ParallelOptions { MaxDegreeOfParallelism = maxThreads };
+
+                    while (currentFreeSpace > targetFreeSpace)
+                    {
+                        Parallel.For(0, maxThreads, options, _ =>
+                        {
+                            lock (rand)
+                            {
+                                var type = fileTypes[rand.Next(fileTypes.Count)];
+                                string folder = folders[rand.Next(folders.Count)];
+                                if (rand.NextDouble() < 0.25)
+                                {
+                                    folder = Path.Combine(folders[rand.Next(folders.Count)], GenerateRandomFolderName());
+                                    Directory.CreateDirectory(folder);
+                                    folders.Add(folder);
+                                }
+
+                                int size = rand.Next(1_000_000, 8_000_000);
+                                GenerateBinaryFile(Path.Combine(folder, GenerateRandomFilename(type.extensions)), size);
+                            }
+                        });
+
+                        currentFreeSpace = new DriveInfo(rootPath).AvailableFreeSpace;
+                        long usedSpace = totalSize - currentFreeSpace;
+
+                        int progressValue = (int)((usedSpace * 100L) / totalSize);
+
+                        progressBar.Invoke((Action)(() =>
+                        {
+                            progressBar.Value = Math.Min(100, progressValue);
+                        }));
+
+                        filesprocessedlabel.Invoke((Action)(() =>
+                        {
+                            filesprocessedlabel.Text = $"{FormatBytes(usedSpace)} / {FormatBytes(totalSize)}";
+                        }));
+                    }
+                });
+
+                MessageBox.Show("Drive filling completed.");
+            }
+        }
+
+        private string FormatBytes(long bytes)
+        {
+            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
+            double len = bytes;
+            int order = 0;
+            while (len >= 1024 && order < sizes.Length - 1)
+            {
+                order++;
+                len /= 1024;
             }
+            return $"{len:0.##} {sizes[order]}";
         }
     }
 }
diff --git a/GiftcardGenerator/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache b/GiftcardGenerator/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache
index 1fb4461..3431654 100644
Binary files a/GiftcardGenerator/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache and b/GiftcardGenerator/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache differ
diff --git a/Notepad/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache b/Notepad/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache
index d99c213..8031c8b 100644
Binary files a/Notepad/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache and b/Notepad/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache differ
diff --git a/SysKey/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache b/SysKey/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache
index 694a658..eb21647 100644
Binary files a/SysKey/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache and b/SysKey/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache differ
diff --git a/netstat/Program.cs b/netstat/Program.cs
index 38ccae2..d85eb0a 100644
--- a/netstat/Program.cs
+++ b/netstat/Program.cs
@@ -1,21 +1,94 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Threading;
+using System.Net;
+using System.Net.Sockets;
 
 namespace netstat
 {
     class Program
     {
+        static string GetLocalLAN()
+        {
+            string result = "192.168.1.100";
+            var host = Dns.GetHostEntry(Dns.GetHostName());
+            foreach (var ip in host.AddressList)
+            {
+                if (ip.AddressFamily == AddressFamily.InterNetwork)
+                {
+                    result = ip.ToString();
+                }
+            }
+            return result;
+        }
+
         static void Main(string[] args)
         {
-            Console.WriteLine("\n");
+            var rand = new Random();
+            int count = rand.Next(25, 75);
+            string lan = GetLocalLAN();
+
+            Console.WriteLine();
             Console.WriteLine("Active Connections");
-            Console.WriteLine("\n");
+            Console.WriteLine();
             Console.WriteLine("  Proto          Local Address           Foreign Address         State");
-            Console.WriteLine("\n\nNo foreign addresses found. Computer is secure from hackers!");
-            Console.WriteLine("\n\n");
+            Console.WriteLine();
+
+            var entries = new List<string>();
+
+            for (int i = 0; i < count; i++)
+            {
+                string proto = rand.Next(0, 2) == 0 ? "TCP" : "UDP";
+                string localIp = lan + ":" + rand.Next(40000, 60000);
+                string foreignIp = rand.Next(10, 255) + "." + rand.Next(0, 255) + "." + rand.Next(0, 255) + "." + rand.Next(0, 255) + ":" + rand.Next(40, 9000);
+
+                string state;
+                if (proto == "UDP")
+                {
+                    state = "LISTENING";
+                }
+                else
+                {
+                    int r = rand.Next(0, 3);
+                    if (r == 0) state = "ESTABLISHED";
+                    else if (r == 1) state = "TIME_WAIT";
+                    else state = "CLOSE_WAIT";
+                }
+
+                string line = "  " + proto.PadRight(6) + "       " + localIp.PadRight(22) + " " + foreignIp.PadRight(22) + " " + state;
+                entries.Add(line);
+                Console.WriteLine(line);
+                Thread.Sleep(250);
+            }
+
+            Console.WriteLine();
+            Thread.Sleep(2500);
+            Console.WriteLine("Securing system, please wait...");
+            Thread.Sleep(1000);
+
+            int total = entries.Count;
+
+            for (int i = 0; i < total; i++)
+            {
+                int width = 100;
+                int progress = (i + 1) * width / total;
+
+                Console.Write("[");
+                Console.Write(new string('#', progress));
+                Console.Write(new string('-', width - progress));
+                Console.Write("] " + ((i + 1) * 100 / total) + "%");
+                Console.SetCursorPosition(0, Console.CursorTop);
+                Thread.Sleep(rand.Next(80, 160));
+            }
+
+            Thread.Sleep(500);
+            Console.Clear();
+            Console.ForegroundColor = ConsoleColor.Green;
+
+            Console.WriteLine();
+            Console.WriteLine("No foreign addresses found. Computer is secure from hackers!");
+            Console.WriteLine();
+
 #if DEBUG
             Console.ReadLine();
 #endif
diff --git a/netstat/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache b/netstat/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache
index 2c31b47..c191874 100644
Binary files a/netstat/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache and b/netstat/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache differ
diff --git a/netstat/obj/Release/netstat.csproj.CoreCompileInputs.cache b/netstat/obj/Release/netstat.csproj.CoreCompileInputs.cache
index 48cbfef..424e5de 100644
--- a/netstat/obj/Release/netstat.csproj.CoreCompileInputs.cache
+++ b/netstat/obj/Release/netstat.csproj.CoreCompileInputs.cache
@@ -1 +1 @@
-ccf839991915f9697dd8d887060e5eafa0df1b69
+979fc59c1f2afcc3443738cd70ff09bf60f7ecb8fbff0eec3eb8b752a83b3e04
diff --git a/netstat/obj/Release/netstat.csproj.FileListAbsolute.txt b/netstat/obj/Release/netstat.csproj.FileListAbsolute.txt
index 78a2d7b..219ee6b 100644
--- a/netstat/obj/Release/netstat.csproj.FileListAbsolute.txt
+++ b/netstat/obj/Release/netstat.csproj.FileListAbsolute.txt
@@ -5,3 +5,10 @@ C:\Users\conno\Source\Repos\ConnorBaxter\ScambaitToolkit\netstat\obj\Release\net
 C:\Users\conno\Source\Repos\ConnorBaxter\ScambaitToolkit\netstat\obj\Release\netstat.exe
 C:\Users\conno\Source\Repos\ConnorBaxter\ScambaitToolkit\netstat\obj\Release\netstat.pdb
 C:\Users\conno\Source\Repos\ConnorBaxter\ScambaitToolkit\netstat\obj\Release\netstat.csprojAssemblyReference.cache
+C:\Users\alex\Documents\GitHub\ScambaitToolkit\netstat\bin\Release\netstat.exe.config
+C:\Users\alex\Documents\GitHub\ScambaitToolkit\netstat\bin\Release\netstat.exe
+C:\Users\alex\Documents\GitHub\ScambaitToolkit\netstat\bin\Release\netstat.pdb
+C:\Users\alex\Documents\GitHub\ScambaitToolkit\netstat\obj\Release\netstat.csproj.AssemblyReference.cache
+C:\Users\alex\Documents\GitHub\ScambaitToolkit\netstat\obj\Release\netstat.csproj.CoreCompileInputs.cache
+C:\Users\alex\Documents\GitHub\ScambaitToolkit\netstat\obj\Release\netstat.exe
+C:\Users\alex\Documents\GitHub\ScambaitToolkit\netstat\obj\Release\netstat.pdb
diff --git a/tree/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache b/tree/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache
index c9e1dec..9b0c30f 100644
Binary files a/tree/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache and b/tree/obj/Release/DesignTimeResolveAssemblyReferencesInput.cache differ