diff --git a/AppPkg/Applications/Python/Efi/getpathp.c b/AppPkg/Applications/Python/Efi/getpathp.c
new file mode 100644
index 0000000000..9f78806611
--- /dev/null
+++ b/AppPkg/Applications/Python/Efi/getpathp.c
@@ -0,0 +1,714 @@
+
+/* Return the initial module search path. */
+/* Used by DOS, OS/2, Windows 3.1, Windows 95/98, Windows NT. */
+
+/* ----------------------------------------------------------------
+   PATH RULES FOR WINDOWS:
+   This describes how sys.path is formed on Windows.  It describes the
+   functionality, not the implementation (ie, the order in which these
+   are actually fetched is different)
+
+   * Python always adds an empty entry at the start, which corresponds
+     to the current directory.
+
+   * If the PYTHONPATH env. var. exists, its entries are added next.
+
+   * We look in the registry for "application paths" - that is, sub-keys
+     under the main PythonPath registry key.  These are added next (the
+     order of sub-key processing is undefined).
+     HKEY_CURRENT_USER is searched and added first.
+     HKEY_LOCAL_MACHINE is searched and added next.
+     (Note that all known installers only use HKLM, so HKCU is typically
+     empty)
+
+   * We attempt to locate the "Python Home" - if the PYTHONHOME env var
+     is set, we believe it.  Otherwise, we use the path of our host .EXE's
+     to try and locate our "landmark" (lib\\os.py) and deduce our home.
+     - If we DO have a Python Home: The relevant sub-directories (Lib,
+       plat-win, lib-tk, etc) are based on the Python Home
+     - If we DO NOT have a Python Home, the core Python Path is
+       loaded from the registry.  This is the main PythonPath key,
+       and both HKLM and HKCU are combined to form the path)
+
+   * Iff - we can not locate the Python Home, have not had a PYTHONPATH
+     specified, and can't locate any Registry entries (ie, we have _nothing_
+     we can assume is a good path), a default path with relative entries is
+     used (eg. .\Lib;.\plat-win, etc)
+
+
+  The end result of all this is:
+  * When running python.exe, or any other .exe in the main Python directory
+    (either an installed version, or directly from the PCbuild directory),
+    the core path is deduced, and the core paths in the registry are
+    ignored.  Other "application paths" in the registry are always read.
+
+  * When Python is hosted in another exe (different directory, embedded via
+    COM, etc), the Python Home will not be deduced, so the core path from
+    the registry is used.  Other "application paths" in the registry are
+    always read.
+
+  * If Python can't find its home and there is no registry (eg, frozen
+    exe, some very strange installation setup) you get a path with
+    some default, but relative, paths.
+
+   ---------------------------------------------------------------- */
+
+
+#include "Python.h"
+#include "osdefs.h"
+
+#ifdef MS_WINDOWS
+#include <windows.h>
+#include <tchar.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif /* HAVE_SYS_TYPES_H */
+
+#ifdef HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif /* HAVE_SYS_STAT_H */
+
+#include <string.h>
+
+/* Search in some common locations for the associated Python libraries.
+ *
+ * Py_GetPath() tries to return a sensible Python module search path.
+ *
+ * The approach is an adaptation for Windows of the strategy used in
+ * ../Modules/getpath.c; it uses the Windows Registry as one of its
+ * information sources.
+ */
+
+#ifndef LANDMARK
+#define LANDMARK "lib\\os.py"
+#endif
+
+static char prefix[MAXPATHLEN+1];
+static char progpath[MAXPATHLEN+1];
+static char dllpath[MAXPATHLEN+1];
+static char *module_search_path = NULL;
+
+
+static int
+is_sep(char ch) /* determine if "ch" is a separator character */
+{
+#ifdef ALTSEP
+    return ch == SEP || ch == ALTSEP;
+#else
+    return ch == SEP;
+#endif
+}
+
+/* assumes 'dir' null terminated in bounds.  Never writes
+   beyond existing terminator.
+*/
+static void
+reduce(char *dir)
+{
+    size_t i = strlen(dir);
+    while (i > 0 && !is_sep(dir[i]))
+        --i;
+    dir[i] = '\0';
+}
+
+
+static int
+exists(char *filename)
+{
+    struct stat buf;
+    return stat(filename, &buf) == 0;
+}
+
+/* Assumes 'filename' MAXPATHLEN+1 bytes long -
+   may extend 'filename' by one character.
+*/
+static int
+ismodule(char *filename)        /* Is module -- check for .pyc/.pyo too */
+{
+    if (exists(filename))
+        return 1;
+
+    /* Check for the compiled version of prefix. */
+    if (strlen(filename) < MAXPATHLEN) {
+        strcat(filename, Py_OptimizeFlag ? "o" : "c");
+        if (exists(filename))
+            return 1;
+    }
+    return 0;
+}
+
+/* Add a path component, by appending stuff to buffer.
+   buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
+   NUL-terminated string with no more than MAXPATHLEN characters (not counting
+   the trailing NUL).  It's a fatal error if it contains a string longer than
+   that (callers must be careful!).  If these requirements are met, it's
+   guaranteed that buffer will still be a NUL-terminated string with no more
+   than MAXPATHLEN characters at exit.  If stuff is too long, only as much of
+   stuff as fits will be appended.
+*/
+static void
+join(char *buffer, char *stuff)
+{
+    size_t n, k;
+    if (is_sep(stuff[0]))
+        n = 0;
+    else {
+        n = strlen(buffer);
+        if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
+            buffer[n++] = SEP;
+    }
+    if (n > MAXPATHLEN)
+        Py_FatalError("buffer overflow in getpathp.c's joinpath()");
+    k = strlen(stuff);
+    if (n + k > MAXPATHLEN)
+        k = MAXPATHLEN - n;
+    strncpy(buffer+n, stuff, k);
+    buffer[n+k] = '\0';
+}
+
+/* gotlandmark only called by search_for_prefix, which ensures
+   'prefix' is null terminated in bounds.  join() ensures
+   'landmark' can not overflow prefix if too long.
+*/
+static int
+gotlandmark(char *landmark)
+{
+    int ok;
+    Py_ssize_t n;
+
+    n = strlen(prefix);
+    join(prefix, landmark);
+    ok = ismodule(prefix);
+    prefix[n] = '\0';
+    return ok;
+}
+
+/* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
+   assumption provided by only caller, calculate_path() */
+static int
+search_for_prefix(char *argv0_path, char *landmark)
+{
+    /* Search from argv0_path, until landmark is found */
+    strcpy(prefix, argv0_path);
+    do {
+        if (gotlandmark(landmark))
+            return 1;
+        reduce(prefix);
+    } while (prefix[0]);
+    return 0;
+}
+
+#ifdef MS_WINDOWS
+#ifdef Py_ENABLE_SHARED
+
+/* a string loaded from the DLL at startup.*/
+extern const char *PyWin_DLLVersionString;
+
+
+/* Load a PYTHONPATH value from the registry.
+   Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
+
+   Works in both Unicode and 8bit environments.  Only uses the
+   Ex family of functions so it also works with Windows CE.
+
+   Returns NULL, or a pointer that should be freed.
+
+   XXX - this code is pretty strange, as it used to also
+   work on Win16, where the buffer sizes werent available
+   in advance.  It could be simplied now Win16/Win32s is dead!
+*/
+
+static char *
+getpythonregpath(HKEY keyBase, int skipcore)
+{
+    HKEY newKey = 0;
+    DWORD dataSize = 0;
+    DWORD numKeys = 0;
+    LONG rc;
+    char *retval = NULL;
+    TCHAR *dataBuf = NULL;
+    static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
+    static const TCHAR keySuffix[] = _T("\\PythonPath");
+    size_t versionLen;
+    DWORD index;
+    TCHAR *keyBuf = NULL;
+    TCHAR *keyBufPtr;
+    TCHAR **ppPaths = NULL;
+
+    /* Tried to use sysget("winver") but here is too early :-( */
+    versionLen = _tcslen(PyWin_DLLVersionString);
+    /* Space for all the chars, plus one \0 */
+    keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
+                                sizeof(TCHAR)*(versionLen-1) +
+                                sizeof(keySuffix));
+    if (keyBuf==NULL) goto done;
+
+    memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
+    keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
+    memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
+    keyBufPtr += versionLen;
+    /* NULL comes with this one! */
+    memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
+    /* Open the root Python key */
+    rc=RegOpenKeyEx(keyBase,
+                    keyBuf, /* subkey */
+            0, /* reserved */
+            KEY_READ,
+            &newKey);
+    if (rc!=ERROR_SUCCESS) goto done;
+    /* Find out how big our core buffer is, and how many subkeys we have */
+    rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
+                    NULL, NULL, &dataSize, NULL, NULL);
+    if (rc!=ERROR_SUCCESS) goto done;
+    if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
+    /* Allocate a temp array of char buffers, so we only need to loop
+       reading the registry once
+    */
+    ppPaths = malloc( sizeof(TCHAR *) * numKeys );
+    if (ppPaths==NULL) goto done;
+    memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
+    /* Loop over all subkeys, allocating a temp sub-buffer. */
+    for(index=0;index<numKeys;index++) {
+        TCHAR keyBuf[MAX_PATH+1];
+        HKEY subKey = 0;
+        DWORD reqdSize = MAX_PATH+1;
+        /* Get the sub-key name */
+        DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
+                                NULL, NULL, NULL, NULL );
+        if (rc!=ERROR_SUCCESS) goto done;
+        /* Open the sub-key */
+        rc=RegOpenKeyEx(newKey,
+                                        keyBuf, /* subkey */
+                        0, /* reserved */
+                        KEY_READ,
+                        &subKey);
+        if (rc!=ERROR_SUCCESS) goto done;
+        /* Find the value of the buffer size, malloc, then read it */
+        RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
+        if (reqdSize) {
+            ppPaths[index] = malloc(reqdSize);
+            if (ppPaths[index]) {
+                RegQueryValueEx(subKey, NULL, 0, NULL,
+                                (LPBYTE)ppPaths[index],
+                                &reqdSize);
+                dataSize += reqdSize + 1; /* 1 for the ";" */
+            }
+        }
+        RegCloseKey(subKey);
+    }
+
+    /* return null if no path to return */
+    if (dataSize == 0) goto done;
+
+    /* original datasize from RegQueryInfo doesn't include the \0 */
+    dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
+    if (dataBuf) {
+        TCHAR *szCur = dataBuf;
+        DWORD reqdSize = dataSize;
+        /* Copy our collected strings */
+        for (index=0;index<numKeys;index++) {
+            if (index > 0) {
+                *(szCur++) = _T(';');
+                dataSize--;
+            }
+            if (ppPaths[index]) {
+                Py_ssize_t len = _tcslen(ppPaths[index]);
+                _tcsncpy(szCur, ppPaths[index], len);
+                szCur += len;
+                assert(dataSize > (DWORD)len);
+                dataSize -= (DWORD)len;
+            }
+        }
+        if (skipcore)
+            *szCur = '\0';
+        else {
+            /* If we have no values, we dont need a ';' */
+            if (numKeys) {
+                *(szCur++) = _T(';');
+                dataSize--;
+            }
+            /* Now append the core path entries -
+               this will include the NULL
+            */
+            rc = RegQueryValueEx(newKey, NULL, 0, NULL,
+                                 (LPBYTE)szCur, &dataSize);
+        }
+        /* And set the result - caller must free
+           If MBCS, it is fine as is.  If Unicode, allocate new
+           buffer and convert.
+        */
+#ifdef UNICODE
+        retval = (char *)malloc(reqdSize+1);
+        if (retval)
+            WideCharToMultiByte(CP_ACP, 0,
+                            dataBuf, -1, /* source */
+                    retval, reqdSize+1, /* dest */
+                    NULL, NULL);
+        free(dataBuf);
+#else
+        retval = dataBuf;
+#endif
+    }
+done:
+    /* Loop freeing my temp buffers */
+    if (ppPaths) {
+        for(index=0;index<numKeys;index++)
+            if (ppPaths[index]) free(ppPaths[index]);
+        free(ppPaths);
+    }
+    if (newKey)
+        RegCloseKey(newKey);
+    if (keyBuf)
+        free(keyBuf);
+    return retval;
+}
+#endif /* Py_ENABLE_SHARED */
+#endif /* MS_WINDOWS */
+
+static void
+get_progpath(void)
+{
+    extern char *Py_GetProgramName(void);
+    char *path = getenv("PATH");
+    char *prog = Py_GetProgramName();
+
+#ifdef MS_WINDOWS
+    extern HANDLE PyWin_DLLhModule;
+#ifdef UNICODE
+    WCHAR wprogpath[MAXPATHLEN+1];
+    /* Windows documents that GetModuleFileName() will "truncate",
+       but makes no mention of the null terminator.  Play it safe.
+       PLUS Windows itself defines MAX_PATH as the same, but anyway...
+    */
+#ifdef Py_ENABLE_SHARED
+    wprogpath[MAXPATHLEN]=_T('\0');
+    if (PyWin_DLLhModule &&
+        GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
+        WideCharToMultiByte(CP_ACP, 0,
+                            wprogpath, -1,
+                            dllpath, MAXPATHLEN+1,
+                            NULL, NULL);
+    }
+#else
+    dllpath[0] = 0;
+#endif
+    wprogpath[MAXPATHLEN]=_T('\0');
+    if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
+        WideCharToMultiByte(CP_ACP, 0,
+                            wprogpath, -1,
+                            progpath, MAXPATHLEN+1,
+                            NULL, NULL);
+        return;
+    }
+#else
+    /* static init of progpath ensures final char remains \0 */
+#ifdef Py_ENABLE_SHARED
+    if (PyWin_DLLhModule)
+        if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
+            dllpath[0] = 0;
+#else
+    dllpath[0] = 0;
+#endif
+    if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
+        return;
+#endif
+#endif
+    if (prog == NULL || *prog == '\0')
+        prog = "python";
+
+    /* If there is no slash in the argv0 path, then we have to
+     * assume python is on the user's $PATH, since there's no
+     * other way to find a directory to start the search from.  If
+     * $PATH isn't exported, you lose.
+     */
+#ifdef ALTSEP
+    if (strchr(prog, SEP) || strchr(prog, ALTSEP))
+#else
+    if (strchr(prog, SEP))
+#endif
+        strncpy(progpath, prog, MAXPATHLEN);
+    else if (path) {
+        while (1) {
+            char *delim = strchr(path, DELIM);
+
+            if (delim) {
+                size_t len = delim - path;
+                /* ensure we can't overwrite buffer */
+                len = MIN(MAXPATHLEN,len);
+                strncpy(progpath, path, len);
+                *(progpath + len) = '\0';
+            }
+            else
+                strncpy(progpath, path, MAXPATHLEN);
+
+            /* join() is safe for MAXPATHLEN+1 size buffer */
+            join(progpath, prog);
+            if (exists(progpath))
+                break;
+
+            if (!delim) {
+                progpath[0] = '\0';
+                break;
+            }
+            path = delim + 1;
+        }
+    }
+    else
+        progpath[0] = '\0';
+}
+
+static void
+calculate_path(void)
+{
+    char argv0_path[MAXPATHLEN+1];
+    char *buf;
+    size_t bufsz;
+    char *pythonhome = Py_GetPythonHome();
+    char *envpath = Py_GETENV("PYTHONPATH");
+
+#ifdef MS_WINDOWS
+    int skiphome, skipdefault;
+    char *machinepath = NULL;
+    char *userpath = NULL;
+    char zip_path[MAXPATHLEN+1];
+    size_t len;
+#endif
+
+    get_progpath();
+    /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
+    strcpy(argv0_path, progpath);
+    reduce(argv0_path);
+    if (pythonhome == NULL || *pythonhome == '\0') {
+        if (search_for_prefix(argv0_path, LANDMARK))
+            pythonhome = prefix;
+        else
+            pythonhome = NULL;
+    }
+    else
+        strncpy(prefix, pythonhome, MAXPATHLEN);
+
+    if (envpath && *envpath == '\0')
+        envpath = NULL;
+
+
+#ifdef MS_WINDOWS
+    /* Calculate zip archive path */
+    if (dllpath[0])             /* use name of python DLL */
+        strncpy(zip_path, dllpath, MAXPATHLEN);
+    else                        /* use name of executable program */
+        strncpy(zip_path, progpath, MAXPATHLEN);
+    zip_path[MAXPATHLEN] = '\0';
+    len = strlen(zip_path);
+    if (len > 4) {
+        zip_path[len-3] = 'z';          /* change ending to "zip" */
+        zip_path[len-2] = 'i';
+        zip_path[len-1] = 'p';
+    }
+    else {
+        zip_path[0] = 0;
+    }
+
+    skiphome = pythonhome==NULL ? 0 : 1;
+#ifdef Py_ENABLE_SHARED
+    machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
+    userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
+#endif
+    /* We only use the default relative PYTHONPATH if we havent
+       anything better to use! */
+    skipdefault = envpath!=NULL || pythonhome!=NULL || \
+                  machinepath!=NULL || userpath!=NULL;
+#endif
+
+    /* We need to construct a path from the following parts.
+       (1) the PYTHONPATH environment variable, if set;
+       (2) for Win32, the zip archive file path;
+       (3) for Win32, the machinepath and userpath, if set;
+       (4) the PYTHONPATH config macro, with the leading "."
+           of each component replaced with pythonhome, if set;
+       (5) the directory containing the executable (argv0_path).
+       The length calculation calculates #4 first.
+       Extra rules:
+       - If PYTHONHOME is set (in any way) item (3) is ignored.
+       - If registry values are used, (4) and (5) are ignored.
+    */
+
+    /* Calculate size of return buffer */
+    if (pythonhome != NULL) {
+        char *p;
+        bufsz = 1;
+        for (p = PYTHONPATH; *p; p++) {
+            if (*p == DELIM)
+                bufsz++; /* number of DELIM plus one */
+        }
+        bufsz *= strlen(pythonhome);
+    }
+    else
+        bufsz = 0;
+    bufsz += strlen(PYTHONPATH) + 1;
+    bufsz += strlen(argv0_path) + 1;
+#ifdef MS_WINDOWS
+    if (userpath)
+        bufsz += strlen(userpath) + 1;
+    if (machinepath)
+        bufsz += strlen(machinepath) + 1;
+    bufsz += strlen(zip_path) + 1;
+#endif
+    if (envpath != NULL)
+        bufsz += strlen(envpath) + 1;
+
+    module_search_path = buf = malloc(bufsz);
+    if (buf == NULL) {
+        /* We can't exit, so print a warning and limp along */
+        fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
+        if (envpath) {
+            fprintf(stderr, "Using environment $PYTHONPATH.\n");
+            module_search_path = envpath;
+        }
+        else {
+            fprintf(stderr, "Using default static path.\n");
+            module_search_path = PYTHONPATH;
+        }
+#ifdef MS_WINDOWS
+        if (machinepath)
+            free(machinepath);
+        if (userpath)
+            free(userpath);
+#endif /* MS_WINDOWS */
+        return;
+    }
+
+    if (envpath) {
+        strcpy(buf, envpath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
+#ifdef MS_WINDOWS
+    if (zip_path[0]) {
+        strcpy(buf, zip_path);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+    }
+    if (userpath) {
+        strcpy(buf, userpath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+        free(userpath);
+    }
+    if (machinepath) {
+        strcpy(buf, machinepath);
+        buf = strchr(buf, '\0');
+        *buf++ = DELIM;
+        free(machinepath);
+    }
+    if (pythonhome == NULL) {
+        if (!skipdefault) {
+            strcpy(buf, PYTHONPATH);
+            buf = strchr(buf, '\0');
+        }
+    }
+#else
+    if (pythonhome == NULL) {
+        strcpy(buf, PYTHONPATH);
+        buf = strchr(buf, '\0');
+    }
+#endif /* MS_WINDOWS */
+    else {
+        char *p = PYTHONPATH;
+        char *q;
+        size_t n;
+        for (;;) {
+            q = strchr(p, DELIM);
+            if (q == NULL)
+                n = strlen(p);
+            else
+                n = q-p;
+            if (p[0] == '.' && is_sep(p[1])) {
+                strcpy(buf, pythonhome);
+                buf = strchr(buf, '\0');
+                p++;
+                n--;
+            }
+            strncpy(buf, p, n);
+            buf += n;
+            if (q == NULL)
+                break;
+            *buf++ = DELIM;
+            p = q+1;
+        }
+    }
+    if (argv0_path) {
+        *buf++ = DELIM;
+        strcpy(buf, argv0_path);
+        buf = strchr(buf, '\0');
+    }
+    *buf = '\0';
+    /* Now to pull one last hack/trick.  If sys.prefix is
+       empty, then try and find it somewhere on the paths
+       we calculated.  We scan backwards, as our general policy
+       is that Python core directories are at the *end* of
+       sys.path.  We assume that our "lib" directory is
+       on the path, and that our 'prefix' directory is
+       the parent of that.
+    */
+    if (*prefix=='\0') {
+        char lookBuf[MAXPATHLEN+1];
+        char *look = buf - 1; /* 'buf' is at the end of the buffer */
+        while (1) {
+            Py_ssize_t nchars;
+            char *lookEnd = look;
+            /* 'look' will end up one character before the
+               start of the path in question - even if this
+               is one character before the start of the buffer
+            */
+            while (look >= module_search_path && *look != DELIM)
+                look--;
+            nchars = lookEnd-look;
+            strncpy(lookBuf, look+1, nchars);
+            lookBuf[nchars] = '\0';
+            /* Up one level to the parent */
+            reduce(lookBuf);
+            if (search_for_prefix(lookBuf, LANDMARK)) {
+                break;
+            }
+            /* If we are out of paths to search - give up */
+            if (look < module_search_path)
+                break;
+            look--;
+        }
+    }
+}
+
+
+/* External interface */
+
+char *
+Py_GetPath(void)
+{
+    if (!module_search_path)
+        calculate_path();
+    return module_search_path;
+}
+
+char *
+Py_GetPrefix(void)
+{
+    if (!module_search_path)
+        calculate_path();
+    return prefix;
+}
+
+char *
+Py_GetExecPrefix(void)
+{
+    return Py_GetPrefix();
+}
+
+char *
+Py_GetProgramFullPath(void)
+{
+    if (!module_search_path)
+        calculate_path();
+    return progpath;
+}