Skip to content

Est. 2011ยทMicrosoft Partner ID 7033487ยทDelivery under 3 minยทSupport 7 days a week

Your vault is empty.

Free Fix 0x0000001A

MEMORY_MANAGEMENT 0x0000001A and PFN_LIST_CORRUPT 0x0000004E blue screens

12 min read Updated October 5, 2026 Windows Crashes & Boot Recovery

Fix it now

0x0000001A is the memory manager reporting a severe error, and parameter 1 says which check failed. Some of those values Microsoft attributes to hardware outright and some describe a driver defect, so read the parameter before you buy memory or start removing drivers.

Run this in an elevated Command Prompt; it scans online and needs no restart

chkdsk C: /scan
  1. Get parameter 1. It is not on the stop screen. Open Event Viewer, find the BugCheck event in the System log, or open the newest file in %SystemRoot%\Minidump and run !analyze -v.
  2. If parameter 1 is 0x31 or 0x403, Microsoft says the error is probably hardware – and for 0x403 particularly so if parameters 3 and 4 differ by a single bit. Test memory before anything else.
  3. Run Windows Memory Diagnostics: type its name at Start, let it restart, and read the MemoryDiagnostics-Results entry in the System log afterwards. Press F1 during the test and set the test mix to Extended for a serious pass.
  4. If parameter 1 describes an MDL or locking mistake instead – 0x1233, 0x1236, 0x1240 and their neighbours – the fault is a driver, not a stick of RAM.
  5. Update third-party drivers from their hardware vendors, and remove software you no longer use that installs kernel components.

For 0x0000004E, the same rule applies with a different table: parameter 1 of 0x06 or 0x8D is attributed to hardware, while 0x07 and 0x9A describe a driver mishandling page locks.

If memory tests clean and the parameter points at a driver, keep reading. The next section covers what each family of parameter values means.

Why it happens

The memory manager keeps a large amount of bookkeeping: page table entries mapping virtual addresses to physical pages, the page frame number database recording the state of every physical page, working set lists, and free and zeroed page lists. Almost all of it is only ever touched by the kernel. When one of those structures is found in a state that cannot legitimately occur, there is nothing sensible to do but stop, because continuing means writing user data through a mapping that no longer means what it says.

0x0000001A is that stop, and its parameter 1 table is long. The values group into three kinds. Some are corruption reports where Microsoft names hardware as the likely cause – 0x31, the image relocation fix-up table or code stream corrupted, and 0x403, page tables and page frame numbers out of sync, which it flags as probably hardware and especially so if parameters 3 and 4 differ by one bit. Some describe a driver doing something illegal: mapping a physical page that was not locked (0x1233), passing an MDL containing an unlocked or invalid physical page (0x1236), building an MDL for a virtual address range that is not resident (0x1240), unlocking a pageable section that is not locked (0x1010). And some are plain corruption of an internal structure with no attribution at all.

0x0000004E is the page frame number list found corrupt, and its published cause is a driver passing a bad memory descriptor list – Microsoft’s example is calling MmUnlockPages twice with the same list. Its parameter 1 table splits the same way: 0x06, hardware PTE or prototype PTE structures corrupted, which it attributes to single-bit errors or broken DMA transfers, and 0x8D, a corrupt page-free list, which it says most likely indicates a hardware issue; against 0x07, a driver unlocking a page more times than it locked it, and 0x9A, a driver freeing a page still locked for I/O.

The two exhaustion codes in this family are frequently misread. 0x00000045 has no published description, parameters, cause or resolution at all – only a symbolic name and a note that it appears very infrequently. 0x0000004D does have documented causes, and none of them is a page table entry leak: a driver blocking and deadlocking the modified or mapped page writers, a storage driver not processing requests, a high-priority realtime thread starving the balance set manager, or not enough pool for the storage stack to write out modified pages.

Failing memory

You have this one if Parameter 1 of 0x31 or 0x403 on 0x1A, or 0x06 or 0x8D on 0x4E. Crashes vary in module and code between occurrences.

  1. Run Windows Memory Diagnostics with the test mix set to Extended, and read the results in the System log.
  2. If more than one module is fitted, test with one at a time to isolate the failing stick.
  3. Return memory to stock timings and voltages before testing. An enabled memory profile is an overclock.
  4. Where the machine is under warranty, a documented parameter value that Microsoft attributes to hardware is useful evidence for the vendor.

A driver mishandling memory descriptor lists or page locks

You have this one if Parameter 1 in the MDL and locking range on 0x1A, or 0x07 or 0x9A on 0x4E. Often a specific workload triggers it.

  1. Identify the driver from the stack with !analyze -v rather than from the stop screen.
  2. Update it from the hardware vendor, or remove the product that supplies it.
  3. On a test machine, run the standard Driver Verifier set against the suspect drivers to force the fault to land on the writer.
  4. Report the dump to the vendor. A published parameter meaning plus a stack is a report they can act on.

The system genuinely ran out of pages

You have this one if The code is 0x0000004D rather than 0x1A or 0x4E.

  1. Read parameters 1 and 2, the dirty page counts. If either is large, suspect a driver blocking the page writers or a storage driver that has stopped processing requests.
  2. If parameter 3, the nonpaged pool available at the time, is small, suspect a shortage of pool for the storage stack instead.
  3. In the debugger, !vm 3 for general memory statistics, !vm 8 followed by !process 0 7 for a stalled storage driver, and !vm with !poolused 2 for the pool case.
  4. For the starvation case, !ready and !process 0 7 show whether a thread has accumulated excessive kernel time at a raised priority.

Storage errors surfacing as memory manager faults

You have this one if Parameter 1 of 0x3f – an inpage operation that failed a cyclic redundancy check – or 0x1A appearing alongside 0x0000007A.

  1. Run chkdsk C: /scan online first, then chkdsk C: /f /r if it reports problems.
  2. Read the drive’s own health data with the manufacturer’s tool.
  3. Check the System log for storage errors immediately before each bug check.
  4. Treat a failing system disk as urgent: image it before you run anything that writes to it.

Full reference

Parameter 1 values on 0x0000001A worth recognising

Value Meaning Where it points
0x31 The image relocation fix-up table or code stream is corrupted Probably hardware
0x3f An inpage operation failed with a CRC error Storage; parameter 2 is the pagefile offset
0x403 Page table and page frame numbers are out of sync Probably hardware, especially if parameters 3 and 4 differ by one bit
0x411 A PTE has been corrupted; parameter 2 is its address Corruption, unattributed
0x1010 Unlocking a pageable section that is not currently locked Driver defect
0x1233 A driver tried to map a physical page that was not locked Driver defect
0x1236 An MDL contains an unlocked or invalid physical page Driver defect
0x1240 An MDL was built for a virtual address range that is not resident Driver defect
0x3451 The PTEs of a swapped-out kernel thread stack are corrupted Corruption, unattributed
0x41790, 0x41792 A page table page, or a PTE, has been corrupted Corruption, unattributed
0x5305 An invalid pool address was specified to free Driver defect
0x6001 The memory store component’s private memory range is corrupted See the store bugchecks

Parameter 1 values on 0x0000004E

Value Meaning Where it points
0x01 The list head was corrupted Corruption, unattributed
0x02 A list entry was corrupted Corruption, unattributed
0x06 Hardware PTE or prototype PTE structures corrupted Single-bit errors, broken DMA transfers
0x07 A driver unlocked a page more times than it locked it Driver defect
0x8D The page-free list is corrupted Most likely hardware
0x8F The free or zeroed page listhead is corrupted Corruption, unattributed
0x99 A PTE or PFN is corrupted Corruption, unattributed
0x9A A driver attempted to free a page still locked for I/O Driver defect

What is and is not published

0x00000045 INSUFFICIENT_SYSTEM_MAP_REGS carries a symbolic name and a note that it appears very infrequently. There is no description, no parameter table, no cause and no resolution. Any article that tells you what it means is inventing it. If you genuinely have one, the only documented step is !analyze on the dump.

0x0000004D is better served. Its four parameters are the total dirty pages, the dirty pages destined for the page file, the nonpaged pool available at the time, and the most recent modified write error status – and those numbers are what select between its four documented causes. A large parameter 1 or 2 points at a blocked page writer or a stalled storage driver; a small parameter 3 points at a pool shortage in the storage stack.

Testing memory so the result means something

  1. Return the machine to stock firmware settings first. Memory profiles, custom timings and any CPU overclock all change the result.
  2. Type Windows Memory Diagnostics at Start and let it restart the machine.
  3. Press F1 during the test and set the test mix to Extended, then F10 to apply and resume.
  4. Let it complete, then read the MemoryDiagnostics-Results entry in the System log.
  5. If it passes and the parameter still says hardware, run several full passes overnight before concluding the memory is sound.

When nothing in the tables matches

  • Compare the codes across several crashes. 0x1A, 0x4E, 0x50 and 0x7A appearing together usually means one underlying fault, not four.
  • Check the System log for storage or WHEA events in the same window as each bug check.
  • Run sfc /scannow, then DISM /Online /Cleanup-Image /RestoreHealth if it reports files it could not repair.
  • On a test machine, run the standard Driver Verifier option set against third-party drivers and let it force the fault onto whoever is writing.
  • If the machine has been reseated, moved or newly built, reseat the memory and check that all modules are the same type.

Every code this article covers

Code What it points at Source
0x0000001A MEMORY_MANAGEMENT: a severe memory management error occurred. Parameter 1 identifies which check failed, and Microsoft attributes several of those values – notably 0x31 and 0x403 – to probable hardware faults Microsoft Learn
0x0000004E PFN_LIST_CORRUPT: the page frame number list is corrupt, typically because a driver passed a bad memory descriptor list, for example calling MmUnlockPages twice with the same list. Parameter 1 values 0x06 and 0x8D are attributed to hardware Microsoft Learn
0x00000045 INSUFFICIENT_SYSTEM_MAP_REGS: Microsoft publishes the symbolic name and the statement that this bug check appears very infrequently. No description, parameters, cause or resolution are given, so it is described here only by what it is not not published by the vendor
0x0000004D NO_PAGES_AVAILABLE: no free pages are available to continue operations. Documented causes are a driver deadlocking the modified or mapped page writers, a storage driver not processing requests, a realtime thread starving the balance set manager, and insufficient pool for the storage stack Microsoft Learn

Confirm the fix worked

  1. Windows Memory Diagnostics completes an extended pass with no errors in the MemoryDiagnostics-Results entry.
  2. chkdsk C: /scan reports no problems, or the problems it reported have been repaired.
  3. The machine runs its normal workload for several days with no new files in %SystemRoot%\Minidump.
  4. If a driver was replaced, Device Manager shows the new version and the same workload no longer crashes.

Questions people ask about this

Is 0x0000001A always bad RAM?

No. Parameter 1 decides. Microsoft attributes 0x31 and 0x403 to probable hardware, but a large part of the table describes drivers misusing memory descriptor lists and page locks, and those are fixed by replacing a driver rather than a stick of memory.

Where do I find parameter 1 if it is not on the screen?

Two places. The BugCheck event in the System log records the code and its parameters, and the dump in %SystemRoot%\Minidump gives the same thing under !analyze -v. Current stop screens show the code, a QR code and sometimes a What failed module, and no parameters at all.

What does 0x00000045 mean?

Nothing that Microsoft publishes. The page carries the symbolic name INSUFFICIENT_SYSTEM_MAP_REGS and a note that it appears very infrequently, and stops there. Treat any confident explanation of it with suspicion.

Is 0x0000004D a memory leak?

Not in the sense people usually mean. Its documented causes are a blocked page writer, a stalled storage driver, a realtime thread starving the balance set manager, and insufficient pool for the storage stack. Adding RAM addresses none of them.

Should I replace the pagefile?

Only if the evidence points there – parameter 1 of 0x3f, which is an inpage CRC failure, or 0x0000007A alongside these codes. Otherwise moving the pagefile changes the timing rather than the fault.

Related error codes

Was this article helpful?

Your feedback helps us improve our documentation.

Related articles

License Error SYSTEM_THREAD_EXCEPTION_NOT_HANDLED 0x0000007E on Windows 10 and 11 Free Fix UNEXPECTED_STORE_EXCEPTION 0x00000154 on Windows 10 and Windows 11 License Error There was a problem resetting your PC – error 0x80070003 in Reset This PC Free Fix VSS writer errors 0x8004230F and 0x80042308 block restore points
โ† Back to Knowledge Base