Backtestshugorun-20261002-200313#15101
hugo --gc deletes in-use image cache files when on-disk path case differs from the cache key (case-insensitive filesystems)
The merged fix was judged better than our patch.
In this judgment, Patch B = our agent, Patch A = the merged fix.
Both patches fix the root cause: the case-sensitive `seen.Has(name)` check in the pruner. They do it in different ways. Patch A matches the walked name against a lowercased index of the seen keys. A name that differs from a used key only in case becomes a candidate, and the decision waits until the walk finishes. The candidate is removed only if the exact-case key was also walked, which proves the two are distinct files on a case-sensitive filesystem. Otherwise it is kept, because on a case-insensitive filesystem it is the same file the build read. This gives the right answer on both kinds of filesystem without asking the filesystem anything. There are no side effects, no extra I/O and no failure modes. The existing semantics for expired or forced removal are preserved: candidates are only considered when `!shouldRemove`, and an exact-seen file still follows the expiry logic. Error handling is consolidated cleanly into a `remove` helper. Patch B detects case-insensitivity at runtime by creating, stat-ing and deleting a probe file in the user's cache root in the middle of the prune walk. That writes into the directory being walked and adds an I/O failure path. On probe failure it defaults to case-insensitive matching, which can keep stale entries on case-sensitive filesystems. It is workable but more fragile and intrusive than A's deterministic approach. Tests: Patch B's simulated case-insensitive afero wrapper is a real strength. Its test runs on every platform and also checks that an unrelated unused entry is still pruned. Patch A tests a real case-insensitive filesystem, which is skipped on Linux, and an end-to-end `hugo --gc` testscript reproducing the issue's scenario, also skipped on Linux. It also adds a MemMapFs case-sensitive test that runs everywhere and confirms distinct-case files are still pruned. A's tests are closer to the real bug, while B's run in more places. On balance this is roughly even. A's additions to `main_test.go` (a testscript condition and a `base64decode` command) exist only to support its testscript, so they are not unrelated churn. Overall, Patch A's fix is more robust and has no side effects, which outweighs B's portability advantage in testing.
The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.
Solve
49m 22s
Wall-clock time in the container
Full test suite
No new failures
3,682 passed · 95 skipped · 3,786 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
211vs 230 merged
Changed lines, ours vs merged
The issue
View on GitHubWhat happens
On a case-insensitive filesystem (macOS APFS, Windows), hugo --gc deletes image cache files under resources/_gen that the build actively uses, if the on-disk path case differs from the cache key. The build itself works fine (the case-insensitive filesystem resolves the read), but the pruner's usage check is a case-sensitive string comparison, so the just-used file is considered unused and removed.
The relevant code is in cache/filecache/filecache_pruner.go (unchanged on master):
if !shouldRemove && c.entryLocker.seen.Len() > 0 {
// Remove it if it's not been touched/used in the last build.
shouldRemove = !c.entryLocker.seen.Has(name)
}
seen contains the cache key (for images: the lowercased target path, via ImageCache.getOrCreate → c.fcache.ReadOrCreate(relTargetPath, …)), while name is the real on-disk name from the filesystem walk. If they differ only in case, seen.Has(name) is false and the file is deleted.
Why the case can differ in practice
Page paths have been lowercased since the v0.123 page-system rewrite, so cache keys for page-bundle images are lowercase. Caches created by older Hugo versions preserve the source directory case (e.g. resources/_gen/images/collections/PastFuture/…). Such caches are common in the wild: committed to git for CI cold-start speed, restored by CI cache plugins, or simply carried forward on a developer machine across Hugo upgrades.
The result is a permanent rebuild/evict cycle: --gc deletes the in-use entries → the next build silently re-processes all of them → the new files land inside the surviving mixed-case directory (the prune walk visits directories before deleting their files, so the directory is never seen empty and survives; on a case-insensitive filesystem the re-created file then lands in it) → the next --gc deletes them again. On the real site where we found this, every build re-scaled 267 images (~35 s per build, forever).
Minimal reproduction (macOS)
hugo new site repro && cd repro
mkdir -p content/MyBundle layouts/_default
printf 'baseURL = "https://example.org/"\ndisableKinds = ["taxonomy", "term", "rss", "sitemap"]\n' > hugo.toml
printf -- '---\ntitle: My Bundle\n---\n' > content/MyBundle/index.md
cp /path/to/any.jpeg content/MyBundle/cover.jpeg
printf '{{ with .Resources.GetMatch "cover.jpeg" }}{{ with .Resize "100x" }}<img src="{{ .RelPermalink }}">{{ end }}{{ end }}' > layouts/_default/single.html
printf 'home' > layouts/_default/home.html
hugo # creates resources/_gen/images/mybundle/cover_hu_<hash>.jpeg
# simulate a cache written by an older Hugo (or copied from elsewhere):
mv resources/_gen/images/mybundle resources/_gen/images/tmp
mv resources/_gen/images/tmp resources/_gen/images/MyBundle
hugo --gc # build succeeds (16 ms, cache hit), but reports "Cleaned 1"
find resources -type f # -> empty: the file the build just used is gone
hugo # re-processes the image (474 ms) — and writes it back
# into the surviving MyBundle/ dir, so the cycle repeats
Observed output of the --gc build:
Processed images │ 1
Cleaned │ 1
Total in 16 ms
A cache file that was read 16 ms earlier is deleted as "not been touched/used in the last build".
What I expected
--gc should never delete a cache entry that the same build read. On case-insensitive filesystems the usage check should match the way the filesystem resolved the read — e.g. compare case-insensitively (or normalize walk names against the seen set) when the cache filesystem is case-insensitive. Renaming the on-disk entry to the key's case would even self-heal old caches.
Version
hugo v0.164.0+extended+withdeploy darwin/arm64 BuildDate=2026-07-06T16:39:30Z VendorInfo=Homebrew
The pruner code is identical on current master.
The two patches
cache/filecache/filecache_pruner.goindex d6322cb70..8c7fefa49 100644@@ -14,9 +14,13 @@ package filecache import (+ "errors" "fmt" "io" "os"+ "strconv"+ "strings"+ "time" "github.com/gohugoio/hugo/common/herrors" "github.com/gohugoio/hugo/hugofs"@@ -59,6 +63,12 @@ func (c *Cache) Prune(force bool) (int, error) { counter := 0 + // Lazily initialized when an unseen entry is found.+ var (+ caseInsensitiveInit bool+ seenLower map[string]bool+ )+ err := afero.Walk(c.Fs, "", func(name string, info os.FileInfo, err error) error { if info == nil { return nil@@ -96,6 +106,28 @@ func (c *Cache) Prune(force bool) (int, error) { if !shouldRemove && c.entryLocker.seen.Len() > 0 { // Remove it if it's not been touched/used in the last build. shouldRemove = !c.entryLocker.seen.Has(name)+ if shouldRemove {+ if !caseInsensitiveInit {+ caseInsensitiveInit = true+ caseInsensitive, err := c.isCaseInsensitiveFs()+ if err != nil {+ // The probe is best-effort (e.g. disk full); don't fail the prune,+ // but err on the side of keeping entries that may be in use.+ caseInsensitive = true+ }+ if caseInsensitive {+ seenLower = make(map[string]bool)+ for id := range c.entryLocker.seen.All() {+ seenLower[strings.ToLower(id)] = true+ }+ }+ }+ if seenLower != nil {+ // On case-insensitive filesystems (e.g. macOS, Windows) the id used+ // in the build may resolve to an on-disk entry with different case.+ shouldRemove = !seenLower[strings.ToLower(name)]+ }+ } } if shouldRemove {@@ -116,6 +148,33 @@ func (c *Cache) Prune(force bool) (int, error) { return counter, err } +// isCaseInsensitiveFs reports whether this cache's filesystem resolves file+// names case-insensitively. It does so by creating a temporary probe file.+func (c *Cache) isCaseInsensitiveFs() (bool, error) {+ probe := "_hugo_gc_CaseProbe_" + strconv.FormatInt(time.Now().UnixNano(), 36)+ f, err := c.Fs.Create(probe)+ if err != nil {+ return false, fmt.Errorf("failed to create case sensitivity probe file: %w", err)+ }+ if err := f.Close(); err != nil {+ return false, errors.Join(err, c.Fs.Remove(probe))+ }++ _, statErr := c.Fs.Stat(strings.ToLower(probe))++ if err := c.Fs.Remove(probe); err != nil {+ return false, fmt.Errorf("failed to remove case sensitivity probe file: %w", err)+ }++ if statErr == nil {+ return true, nil+ }+ if herrors.IsNotExist(statErr) {+ return false, nil+ }+ return false, statErr+}+ func (c *Cache) pruneRootDirs(force bool) (int, error) { dirs, err := afero.ReadDir(c.Fs, "") if err != nil {cache/filecache/filecache_pruner_test.goindex 117ff3430..797fba352 100644@@ -15,6 +15,9 @@ package filecache_test import ( "fmt"+ "os"+ "path/filepath"+ "strings" "testing" "testing/synctest" "time"@@ -113,3 +116,152 @@ dir = ":resourceDir/_gen" } }) }++// Issue: hugo --gc deleted in-use cache files on case-insensitive filesystems+// when the on-disk case differed from the cache key.+func TestPruneCaseInsensitiveFs(t *testing.T) {+ t.Parallel()++ configStr := `+resourceDir = "myresources"+[caches]+[caches.images]+maxAge = -1+dir = ":resourceDir/_gen"+`++ for _, caseInsensitive := range []bool{true, false} {+ t.Run(fmt.Sprintf("caseInsensitive=%t", caseInsensitive), func(t *testing.T) {+ c := qt.New(t)+ var fs afero.Fs = afero.NewMemMapFs()+ if caseInsensitive {+ fs = caseInsensitiveFs{fs}+ }+ p := newPathsSpec(t, fs, configStr)+ caches, err := filecache.NewCaches(p.Cfg.GetConfigSection("caches").(filecache.Configs), fs)+ c.Assert(err, qt.IsNil)+ caches.SetResourceFs(fs)+ cache := caches[filecache.CacheKeyImages]++ // Simulate a cache written by an older Hugo version that preserved the directory case.+ c.Assert(afero.WriteFile(cache.Fs, filepath.FromSlash("MyBundle/cover.jpg"), []byte("cached"), 0o666), qt.IsNil)+ c.Assert(afero.WriteFile(cache.Fs, filepath.FromSlash("MyBundle/unused.jpg"), []byte("unused"), 0o666), qt.IsNil)++ created := false+ _, b, err := cache.GetOrCreateBytes(filepath.FromSlash("mybundle/cover.jpg"), func() ([]byte, error) {+ created = true+ return []byte("created"), nil+ })+ c.Assert(err, qt.IsNil)++ count, err := caches.Prune()+ c.Assert(err, qt.IsNil)++ if caseInsensitive {+ // The build read the existing file; it must survive the prune.+ c.Assert(created, qt.IsFalse)+ c.Assert(string(b), qt.Equals, "cached")+ c.Assert(count, qt.Equals, 1)+ } else {+ c.Assert(created, qt.IsTrue)+ c.Assert(count, qt.Equals, 2)+ }++ var files []string+ c.Assert(afero.Walk(cache.Fs, "", func(path string, info os.FileInfo, err error) error {+ if err != nil {+ return err+ }+ if !info.IsDir() {+ files = append(files, filepath.ToSlash(strings.TrimPrefix(path, string(filepath.Separator))))+ }+ return nil+ }), qt.IsNil)++ if caseInsensitive {+ c.Assert(files, qt.DeepEquals, []string{"MyBundle/cover.jpg"})+ } else {+ c.Assert(files, qt.DeepEquals, []string{"mybundle/cover.jpg"})+ }+ c.Assert(cache.GetString(filepath.FromSlash("mybundle/cover.jpg")), qt.Not(qt.Equals), "")+ })+ }+}++// caseInsensitiveFs resolves names case-insensitively against existing+// entries, preserving the case of existing entries, like e.g. macOS APFS.+type caseInsensitiveFs struct {+ afero.Fs+}++func (fs caseInsensitiveFs) resolve(name string) string {+ name = filepath.Clean(name)+ parts := strings.Split(name, string(filepath.Separator))+ resolved := parts[0]+ for i, part := range parts[1:] {+ dir := resolved+ if dir == "" {+ dir = string(filepath.Separator)+ }+ fis, err := afero.ReadDir(fs.Fs, dir)+ if err != nil {+ return filepath.Join(append([]string{dir}, parts[i+1:]...)...)+ }+ for _, fi := range fis {+ if strings.EqualFold(fi.Name(), part) {+ part = fi.Name()+ break+ }+ }+ resolved = filepath.Join(dir, part)+ }+ return resolved+}++func (fs caseInsensitiveFs) Create(name string) (afero.File, error) {+ return fs.Fs.Create(fs.resolve(name))+}++func (fs caseInsensitiveFs) Mkdir(name string, perm os.FileMode) error {+ return fs.Fs.Mkdir(fs.resolve(name), perm)+}++func (fs caseInsensitiveFs) MkdirAll(path string, perm os.FileMode) error {+ return fs.Fs.MkdirAll(fs.resolve(path), perm)+}++func (fs caseInsensitiveFs) Open(name string) (afero.File, error) {+ return fs.Fs.Open(fs.resolve(name))+}++func (fs caseInsensitiveFs) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {+ return fs.Fs.OpenFile(fs.resolve(name), flag, perm)+}++func (fs caseInsensitiveFs) Remove(name string) error {+ return fs.Fs.Remove(fs.resolve(name))+}++func (fs caseInsensitiveFs) RemoveAll(path string) error {+ return fs.Fs.RemoveAll(fs.resolve(path))+}++func (fs caseInsensitiveFs) Rename(oldname, newname string) error {+ return fs.Fs.Rename(fs.resolve(oldname), fs.resolve(newname))+}++func (fs caseInsensitiveFs) Stat(name string) (os.FileInfo, error) {+ return fs.Fs.Stat(fs.resolve(name))+}++func (fs caseInsensitiveFs) Chmod(name string, mode os.FileMode) error {+ return fs.Fs.Chmod(fs.resolve(name), mode)+}++func (fs caseInsensitiveFs) Chown(name string, uid, gid int) error {+ return fs.Fs.Chown(fs.resolve(name), uid, gid)+}++func (fs caseInsensitiveFs) Chtimes(name string, atime, mtime time.Time) error {+ return fs.Fs.Chtimes(fs.resolve(name), atime, mtime)+}
cache/filecache/filecache_pruner.goindex d6322cb70..cd95766be 100644@@ -17,6 +17,7 @@ import ( "fmt" "io" "os"+ "strings" "github.com/gohugoio/hugo/common/herrors" "github.com/gohugoio/hugo/hugofs"@@ -59,6 +60,29 @@ func (c *Cache) Prune(force bool) (int, error) { counter := 0 + seen := c.entryLocker.seen+ seenByLower := make(map[string]string, seen.Len())+ for id := range seen.All() {+ seenByLower[strings.ToLower(id)] = id+ }++ // Names on disk matching a used cache key except for the case, and the used keys+ // actually walked. See the note about case-insensitive filesystems below.+ var candidates map[string]string+ visited := make(map[string]bool, seen.Len())++ remove := func(name string) error {+ err := c.Fs.Remove(name)+ if err == nil {+ counter+++ return nil+ }+ if !herrors.IsNotExist(err) {+ return err+ }+ return nil+ }+ err := afero.Walk(c.Fs, "", func(name string, info os.FileInfo, err error) error { if info == nil { return nil@@ -93,27 +117,44 @@ func (c *Cache) Prune(force bool) (int, error) { shouldRemove := force || c.isExpired(info.ModTime()) - if !shouldRemove && c.entryLocker.seen.Len() > 0 {- // Remove it if it's not been touched/used in the last build.- shouldRemove = !c.entryLocker.seen.Has(name)+ if seen.Has(name) {+ visited[name] = true+ } else if !shouldRemove && seen.Len() > 0 {+ if id, found := seenByLower[strings.ToLower(name)]; found {+ // On case-insensitive filesystems this is the same file as id; e.g. an+ // entry created before Hugo started lowercasing the content paths in+ // v0.123 (content/MyBundle => _gen/images/MyBundle). Decided once the+ // walk is done: if id is walked too, they are distinct files and this+ // one is stale. See issue 15101.+ if candidates == nil {+ candidates = make(map[string]string)+ }+ candidates[name] = id+ } else {+ // Remove it if it's not been touched/used in the last build.+ shouldRemove = true+ } } if shouldRemove {- err := c.Fs.Remove(name)- if err == nil {- counter++- }-- if err != nil && !herrors.IsNotExist(err) {- return err- }-+ return remove(name) } return nil })+ if err != nil {+ return counter, err+ }++ for name, id := range candidates {+ if visited[id] {+ if err := remove(name); err != nil {+ return counter, err+ }+ }+ } - return counter, err+ return counter, nil } func (c *Cache) pruneRootDirs(force bool) (int, error) {cache/filecache/filecache_pruner_test.goindex 117ff3430..dc01e417a 100644@@ -20,11 +20,72 @@ import ( "time" "github.com/gohugoio/hugo/cache/filecache"+ "github.com/gohugoio/hugo/htesting" "github.com/spf13/afero" qt "github.com/frankban/quicktest" ) +// A cache entry created before Hugo started lowercasing content paths in v0.123+// (e.g. _gen/images/MyBundle) is on a case-insensitive filesystem the same file as+// the lowercased cache key used today, and must not be pruned.+// See issue 15101.+func TestPruneCacheEntryWithOtherCase(t *testing.T) {+ t.Parallel()+ c := qt.New(t)++ dir := t.TempDir()+ if isCaseInsensitive, err := htesting.IsCaseInsensitiveFs(dir); err != nil {+ t.Fatal(err)+ } else if !isCaseInsensitive {+ t.Skip("skip test on case-sensitive filesystem")+ }++ fs := afero.NewBasePathFs(afero.NewOsFs(), dir)+ newCache := func() *filecache.Cache {+ return filecache.NewCache(fs, filecache.FileCacheConfig{Dir: "cache", MaxAge: -1})+ }++ c.Assert(newCache().SetBytes("MyBundle/i1", []byte("abc")), qt.IsNil)++ cache := newCache()+ _, b, err := cache.GetOrCreateBytes("mybundle/i1", func() ([]byte, error) {+ return []byte("def"), nil+ })+ c.Assert(err, qt.IsNil)+ c.Assert(string(b), qt.Equals, "abc")++ count, err := cache.Prune(false)+ c.Assert(err, qt.IsNil)+ c.Assert(count, qt.Equals, 0)+ c.Assert(cache.GetString("MyBundle/i1"), qt.Equals, "abc")+}++// On a case-sensitive filesystem the entries above are distinct files,+// and the one not used in this build should be pruned.+func TestPruneCacheEntryWithOtherCaseCaseSensitiveFs(t *testing.T) {+ t.Parallel()+ c := qt.New(t)++ fs := afero.NewMemMapFs()+ cache := filecache.NewCache(fs, filecache.FileCacheConfig{Dir: "cache", MaxAge: -1})++ c.Assert(cache.SetBytes("MyBundle/i1", []byte("abc")), qt.IsNil)++ cache = filecache.NewCache(fs, filecache.FileCacheConfig{Dir: "cache", MaxAge: -1})+ _, b, err := cache.GetOrCreateBytes("mybundle/i1", func() ([]byte, error) {+ return []byte("def"), nil+ })+ c.Assert(err, qt.IsNil)+ c.Assert(string(b), qt.Equals, "def")++ count, err := cache.Prune(false)+ c.Assert(err, qt.IsNil)+ c.Assert(count, qt.Equals, 1)+ c.Assert(cache.GetString("MyBundle/i1"), qt.Equals, "")+ c.Assert(cache.GetString("mybundle/i1"), qt.Equals, "def")+}+ func TestPrune(t *testing.T) { t.Parallel() htesting/test_helpers.goindex 384695df4..46f6bd9ec 100644@@ -16,6 +16,7 @@ package htesting import ( "math/rand" "os"+ "path/filepath" "regexp" "runtime" "strconv"@@ -58,6 +59,27 @@ func CreateTempDir(fs afero.Fs, prefix string) (string, func(), error) { return tempDir, func() { fs.RemoveAll(tempDir) }, nil } +// IsCaseInsensitiveFs reports whether dir lives on a case-insensitive filesystem+// (e.g. the default on macOS and Windows).+func IsCaseInsensitiveFs(dir string) (bool, error) {+ f, err := os.CreateTemp(dir, "case-*.tmp")+ if err != nil {+ return false, err+ }+ f.Close()+ defer os.Remove(f.Name())++ _, err = os.Stat(filepath.Join(dir, strings.ToUpper(filepath.Base(f.Name()))))+ if err != nil {+ if os.IsNotExist(err) {+ return false, nil+ }+ return false, err+ }++ return true, nil+}+ // BailOut panics with a stack trace after the given duration. Useful for // hanging tests. func BailOut(after time.Duration) {main_test.goindex 12e708dc0..8cea78818 100644@@ -15,6 +15,7 @@ package main import ( "bytes"+ "encoding/base64" "encoding/json" "fmt" "io"@@ -27,6 +28,7 @@ import ( "runtime" "strconv" "strings"+ "sync" "testing" "time" @@ -78,10 +80,22 @@ func TestMain(m *testing.M) { }) } +var isCaseInsensitiveFs = sync.OnceValues(func() (bool, error) {+ return htesting.IsCaseInsensitiveFs(os.TempDir())+})+ var commonTestScriptsParam = testscript.Params{ Setup: func(env *testscript.Env) error { return testSetupFunc()(env) },+ Condition: func(cond string) (bool, error) {+ switch cond {+ case "caseinsensitivefs":+ return isCaseInsensitiveFs()+ default:+ return false, fmt.Errorf("unknown condition %q", cond)+ }+ }, Cmds: map[string]func(ts *testscript.TestScript, neg bool, args []string){ // log prints to stderr. "log": func(ts *testscript.TestScript, neg bool, args []string) {@@ -252,6 +266,34 @@ var commonTestScriptsParam = testscript.Params{ ts.Fatalf("failed to create symlink: %v", err) } },+ // base64decode decodes a base64-encoded file into a binary file.+ "base64decode": func(ts *testscript.TestScript, neg bool, args []string) {+ if len(args) != 2 {+ ts.Fatalf("usage: base64decode src_base64_file dest_binary_file")+ }++ // Resolve paths relative to the test sandbox's current directory+ src := ts.MkAbs(args[0])+ dest := ts.MkAbs(args[1])++ // Read the base64 text+ base64Data, err := os.ReadFile(src)+ if err != nil {+ ts.Fatalf("failed to read base64 file: %v", err)+ }++ // Decode base64 back to raw bytes.+ binaryBytes, err := base64.StdEncoding.DecodeString(strings.TrimSpace(string(base64Data)))+ if err != nil {+ ts.Fatalf("failed to decode base64 data: %v", err)+ }++ // Write the binary file.+ err = os.WriteFile(dest, binaryBytes, 0o644)+ if err != nil {+ ts.Fatalf("failed to write binary file: %v", err)+ }+ }, // httpget checks that a HTTP resource's body matches (if it compiles as a regexp) or contains all of the strings given as arguments. "httpget": func(ts *testscript.TestScript, neg bool, args []string) {testscripts/commands/hugo_gc_mixed_case_cache_dir.txtnew file mode 100644index 000000000..7c7af1373@@ -0,0 +1,38 @@+# In Hugo v0.123 we started lowercasing the content paths, but on case-insensitive+# filesystems existing caches keep their mixed-case dir names (e.g. MyBundle).+# The pruner would then consider those entries unused and remove them on every+# hugo --gc. See issue 15101.++[!caseinsensitivefs] skip++base64decode pixel.png.txt content/MyBundle/pix.png++hugo++stdout 'Processed images │ 1 '+tree resources/_gen+stdout 'pix_hu_a354833fd576551d.png'++# Simulate a cache created by an older Hugo version.+mv resources/_gen/images/mybundle resources/_gen/images/MyBundle++hugo --gc+stdout 'Cleaned │ 0 '++tree resources/_gen+stdout 'pix_hu_a354833fd576551d.png'++-- hugo.toml --+disableKinds = ["term", "taxonomy", "home"]+-- layouts/all.html --+All.+-- layouts/page.html --+{{ $pix := .Resources.Get "pix.png" }}+{{ $resized := $pix.Resize "10x10" }}+Resized: {{ $resized.RelPermalink }}+-- content/MyBundle/index.md --+---+title: MyBundle+---+-- pixel.png.txt --+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==