C#

using System;
using System.Data;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Principal;
using System.Security.Permissions;
using System.Web.Security;
using System.Web;
using System.Runtime.CompilerServices;
[assembly:AllowPartiallyTrustedCallers]

namespace NationallyKnownPoliticallyContentiousProjectThatIAmNotAtLibertyToDisclose.data
{
    public class ImpersonationManager
    {
        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
        public static extern bool LogonUser(String lpszUsername, String lpszDomain, String lpszPassword, int dwLogonType, int dwLogonProvider, ref IntPtr phToken); 
 
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern bool CloseHandle(IntPtr handle);

        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern bool DuplicateToken(IntPtr hToken, int SECURITY_IMPERSONATION_LEVEL, ref IntPtr hDuplicateToken); 
 
        [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern bool RevertToSelf();

        public static string Domain { get; set; }
        public static string UserName { get; set; }
        public static string Password { get; set; }
        private static WindowsImpersonationContext _context;

        [PermissionSetAttribute(SecurityAction.Demand, Name = "FullTrust")]
        public static void BeginImpersonation()
        {
            const int LOGON32_PROVIDER_DEFAULT = 0;
            const int LOGON32_LOGON_INTERACTIVE = 2;

            IntPtr tokenHandle = IntPtr.Zero;
            try
            {
                bool successfulLogin = LogonUser(UserName, Domain, Password, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, ref tokenHandle);
                if (successfulLogin) //if !successful, there will be an exception
                {
                    WindowsIdentity identity = new WindowsIdentity(tokenHandle);
                    _context = identity.Impersonate();
                }
            }
            catch (Exception ex)
            {
                throw ex; //just trapping for quick debugging purposes. I put a breakpoint here.
            }
            finally
            {
                if (tokenHandle != IntPtr.Zero)
                    CloseHandle(tokenHandle);

            }
        }
        public static void EndImpersonation()
        {
            _context.Undo();
        }
    }
}

public static void DeliverOutbound(string document, MessageType messageInfo)
        {
            WindowsImpersonationContext context = null;
            try
            {
                string filePath = data.StaticDataClassTEMP.getFileSavePath(); //pulls from xml
                string archivePath = data.StaticDataClassTEMP.getArchiveSavePath(); //pulls from xml

                XmlDocument xDocument = new XmlDocument();
                xDocument.Load(HttpContext.Current.Server.MapPath("~/data/ApplicationSettings.xml"));

                ImpersonationManager.UserName = xDocument.DocumentElement.SelectSingleNode("username").InnerText;
                ImpersonationManager.Password = xDocument.DocumentElement.SelectSingleNode("password").InnerText;
                ImpersonationManager.Domain = xDocument.DocumentElement.SelectSingleNode("domain").InnerText;
                ImpersonationManager.BeginImpersonation();

                WriteArchive(document, messageInfo, archivePath);
                DeliverZip(document, messageInfo, filePath);
                //Do_Other_ProcessThatWouldGiveAwayNameOfProject();
                ImpersonationManager.EndImpersonation();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
            }
        }

<username>processID</username>
  <password>processPW</password>
  <domain>Corp</domain>

for (int k = 0; k < 2000; k++) {
    for (int i = 0; i < 2000; i++) {
        for (int j = 0; j < 2000; j++) {
            G[i, j] = Math.Min(G[i, j], G[i, k] + G[k, j]);
        }
    }
}

for (int k = 0; k < 2000; k++) {
    for (int i = 0; i < 2000; i++) {
        if (i==k) {
             for (int j = 0; j < 2000; j++) {
                G[i, j] = Math.Min(G[i, j], G[i, k] + G[k, j]);
            }
       } else {
            //G[i, j] = Math.Min(G[i, j], G[i, j] + G[j, j]);  // special case k==j
            G[i, k] = Math.Min(G[i, k], G[i, k] + G[k, k]);  // special case k==j
            for (int j = 0; j < 2000; j++) {
                if (j!=k) G[i, j] = Math.Min(G[i, j], G[i, k] + G[k, j]);
            }
        }
    }
}