struct Widget
{
    ⟦ ... other stuff ... ⟧

    bool await_ready() const { return ⟦ ... ⟧; }

    bool await_suspend(std::coroutine_handle<> handle)
    {
        int priority = ??? how do I get a priority ???;

        return internal_start(handle, priority);
    }

    auto await_resume() { return ⟦ ... ⟧; }
};

// This doesn't work
auto result = co_await (widget, priority);

So how do you pass two parameters to co_await so they can be used in await_suspend?

It’s a trick question. You can’t. The co_await operator takes only one parameter.

So you’ll have to take all the things you want to use and put them into a single parameter.

Wrap the awaitable object and its parameters into a larger object, and then await the larger object.

First, let’s rename away the coroutine methods inside Widget since we aren’t awaiting it directly any more.

struct Widget
{
    ⟦ ... other stuff ... ⟧

private:
    bool inner_await_ready() const { return ⟦ ... ⟧; }

    bool inner_await_suspend(std::coroutine_handle<> handle)
    {
        int priority = ??? how do I get a priority ???;

        return internal_start(handle, priority);
    }

    auto inner_await_resume() const { return ⟦ ... ⟧; }
};

Now we can add a priority parameter to the inner_await_suspend:

struct Widget
{
    ⟦ ... other stuff ... ⟧

private:
    bool inner_await_ready() const { return ⟦ ... ⟧; }

    bool inner_await_suspend(std::coroutine_handle<> handle, int priority)
    {
        return internal_start(handle, priority);
    }

    auto inner_await_resume() const { return ⟦ ... ⟧; }
};

And finally, we create a helper class (which is a friend of Widget) that wraps the original object and its priority into a single new awaitable object.

struct Widget
{
    ⟦ ... other stuff ... ⟧

private:
    friend struct widget_with_priority;

    ⟦ ... as before ... ⟧
};

struct widget_with_priority                                          
{                                                                    
    widget_with_priority(Widget const& widget, int priority) :       
        m_widget(widget), m_priority(priority) {}                    
                                                                     
    bool await_ready() const { return m_widget.inner_await_ready(); }
                                                                     
    auto await_suspend(std::coroutine_handle<> handle)               
    {                                                                
        return m_widget.inner_await_suspend(handle, m_priority);     
    }                                                                
                                                                     
    auto await_ready() {                                             
        return m_widget.await_ready();                               
    }                                                                
                                                                     
    Widget const& m_widget;                                          
    int m_priority;                                                  
};                                                                   

You can now do

co_await widget_with_priority(widget, priority);

This solves the problem but is rather unwieldy. We’ll address that next time.

The post How can I pass more than one parameter to <CODE>co_await</CODE>? appeared first on The Old New Thing.

This reminded me that back in the day I did something similar, but much less impressive: I wrote a reboot.com program that could be generated from the command line via echo.

echo Alt+Num2,Num0,Num5Ctrl+Y>reboot.com

The Alt+Num2,Num0,Num5 means to press and hold the Alt while sequentially pressing and releasing Num2, Num0, Num5 on the numeric keypad, and then releasing the Alt key. In the IBM PC 437 code page, this comes out looking like ═, which is character 205, or hex 0xCD.

The byte 0xCD is the machine code for the int instruction, for issuing a software interrupt. And Ctrl+Y generates character 25, or hex 0x19, which completes the instruction: int 19h.

Interrupt 19h was a sort-of not-very-good “reboot the system” interrupt. You can read about all the problems it has in Ralph Brown’s Interrupt List.

This interrupt reboots the system without clearing memory or restoring interrupt vectors. Because interrupt vectors are preserved, this interrupt usually causes a system hang if any TSRs have hooked vectors from 00h through 1Ch, particularly INT 08.

Since this was not a very good way of rebooting the system, it was mostly just a parlor trick.

But at least I did it.

The post I didn’t write a program with emoji, but I did use a control character appeared first on The Old New Thing.

                                                                         May 4, 1987

                                 EMPLOYEE PRICE LIST

 PART                            EMPLOYEE       PART                             EMPLOYEE
NUMBER       DESCRIPTION           PRICE        NUMBER       DESCRIPTION           PRICE 

             FORTRAN                                    MULTIPLAN
005-014v400   MS-DOS               $30.00       023-014v203   MS-DOS 3.0           $15.00
005-023       SOFTCARD             $10.00       023-022       APPLE II (NATIVE)    $15.00
005-092v331   XENIX 286            $30.00       023-096v111   MACINTOSH            $15.00
005-096v220   MACINTOSH            $20.00       
                                                             PROJECT
             A.L.D.S.                           027-014v301   IBM                  $30.00
006-023       SOFTCARD             $20.00       026-214v300   COURSEWARE           $30.00
                                                
             BASIC COMPILER                                  FLIGHT SIMULATOR
007-014v536   MS-DOS               $15.00       030-096v102   MACINTOSH            $10.00
007-023       SOFTCARD             $25.00       030-099v213   IBM                  $10.00
007-096v100   MACINTOSH 1.0        $20.00       
007-114v300   QUICKBASIC           $ 5.00                    FILE
                                                033-096v105   MACINTOSH            $15.00
             MUMATH/MUSIMP               
009-014v412   MS-DOS               $20.00                    WORD
                                                034-049v300   NETWORK              $45.00
             COBOL                              034-049-034   NETWORK WORKSTATION  $20.00
011-014v210   MS-DOS               $25.00       034-096v301   MACINTOSH            $ TBA
011-023       SOFTCARD             $20.00       034-099v311   IBM                  $40.00
011-092       XENIX 286            $30.00       034-214v310   COURSEWARE 3.1 DOS   $35.00
                                                034-296v300   COURSEWARE 3.1 MAC   $25.00
             BASIC INTERPRETER           
014-014       MS-DOS               $20.00                    CHART
014-092v541   XENIX 286            $15.00       035-096v102   MACINTOSH 1.02       $15.00
014-096v300   MACINTOSH            $15.00       035-099v203   IBM                  $15.00
                                                035-214v200   COURSEWARE 2.0 DOS   $25.00
             MACRO ASSEMBLER             
016-014v400   MS-DOS               $20.00                    MS-DOS
                                                036-214v321   DOS/GW-BASIC         $15.00
             SORT                        
017-014       MS-DOS               $20.00                    BUS MOUSE
                                                037-299v602   IBM                  $40.00
             LISP                               037-399v600   Inport Mouse         $30.00
018-014v510   MS-DOS               $30.00       
                                                             SERIAL MOUSE
             PASCAL COMPILER                    039-199v602   IBM                  $45.00
020-014v332   MS-DOS               $30.00       
020-092v331   XENIX 286            $35.00                    BUSINESS BASIC COMPILER
                                                045-014       MS-DOS               $20.00

Page two:

                                                                         May 4, 1897

 PART                            EMPLOYEE       PART                             EMPLOYEE
NUMBER       DESCRIPTION           PRICE        NUMBER       DESCRIPTION           PRICE 

             APPLESOFT COMPILER
023-022       APPLE II             $15.00

             C COMPILER
048-014v400   MS-DOS               $35.00

             WINDOWS
050-050v104   IBM
               (retail version)    $10.00
050-150v103   WINDOWS TOOLKIT ISV
               (developers only)   $40.00
050-051v104   WINDOWS 3.5"         $10.00

             MACH 10
058-099       WITH WINDOWS        $185.00
058-199       BOARD ONLY          $130.00

             EXCEL
065-096v104   MACINTOSH            $20.00
065-196       "HANDS ON EXCEL"
                WORKBOOK           $20.00

             ACCESS
066-099v101   IBM                  $20.00

070-096v100  MICROSOFT WORKS       $20.00

             LEARN M/P & CHART
082-096       MACINTOSH            $ 5.00

089-014v101  LEARNING DOS          $ 5.00

094-014      COBOL TOOLS IBM       $15.00

094-092      COBOL XENIX TOOLS     $15.00

There are other pages for books from Microsoft Press, which I didn’t bother to reproduce here.

A.L.D.S. is the Assembly Language Development System, a software development system for CP/M. muMATH/muSIMP was a lisp system disguised as a symbolic mathematics package. (muMath was the symbolic mathematics part; muSimp was the lisp part.)

I’ve talked about some of these products before:

• Flight Simulator is probably Microsoft’s oldest continuing product. There was that time a customer reported an error in the map.
• Access is a telecommunications program. The name was later reused for a database program.
• FORTRAN was succeeded much later by Fortran PowerStation, which was not a resounding success.
• The Mach 10 was not very successful either, but at least it did better than the Mach 20 for OS/2!
• The source code for the Applesoft Compiler became shrouded in mystery. I have a follow-up to that story, but haven’t had time to research it and write it up.
• The Microsoft Softcard was a plug-in board that you added to your Apple II to turn it into a CP/M system. It looks like a good number of programming languages were available in a Softcard edition.

The post Microsoft employee price list from 1987 appeared first on The Old New Thing.

Microsoft issues hot patches for two updates in a row. I linked to it in the original article, and here it is again: Hotpatch for Windows client now available.

Notice in the diagram that Windows supports two hot-patch cycles before forcing a traditional update.

Hot-patch track

Hot-patch update

→

Hot-patch update

Hot-patch update

→

Hot-patch update

Traditional track

Traditional update

→

Traditional update

→

Traditional update

→

Traditional update

→

Traditional update

→

Traditional update

→

Traditional update

Jan baseline

Feb

Mar

Apr baseline

May

Jun

Jul baseline

The first month of each quarter issues a traditional update. Administrators who opted into the hot-patch track can install two months of hot patches, while everybody else continues to get traditional updates. At the start of the next quarter, everybody gets a traditional update again, and the cycle continues.

Okay, so how can Windows Update apply a hot-patch on top of another hot-patch?

Why can’t you tickle yourself?

Your brain knows that you’re the one doing the tickling, so it suppresses the tickle response.

And Windows Update knows that it’s patching something that it already patched, so it knows what it did to apply the hot-patch, and therefore it knows what code was originally there before it performed the hot-patch. I think all it has to do to patch a patch is update the far jump target in the trampoline to point to the new hot-patch function.

I suspect that the limit of two stacked hot-patches avoids an unbounded accumulation of internal data structures that are used to keep track of all the hot-patches, and to ensure we don’t run out of patch space in the binary itself.

The post If the Windows Update hot patcher checks that the function hasn’t already been patched, does that mean you can’t install two hot-patches? appeared first on The Old New Thing.

For processors with variable-length instructions (looking at you, x86), the patched instruction cannot be shorter than its replacement. This applies even if you can suspend all the threads of the process, because you might suspend a thread just as it’s about to execute bytes from what would be the second of half of the replacement instruction.

If you were unlucky and froze the thread after it executed the XX instruction and was about to execute the YY instruction, and then replaced both bytes with a two-byte instruction AA BB, then when the thread resumes, it will execute BB as if it were the start of a new instruction.

Okay fine, so we’ll make sure that the original instruction is at least as big as the replacement instruction, so that a frozen thread is never caught in the middle of the replacement instruction. But assuming we do that, can’t we just suspend all the threads, and then patch at will without having to worry about atomicity?

While it’s true that you suspended all the threads in the process, that doesn’t prevent new threads from being created in the process by a function like Create­Remote­Thread. The caller of Create­Remote­Thread can specify whether the new thread is suspended or not, and if it chooses non-suspended (or if it chose suspended and then decided to resume it), you now have a live thread running in the process while you are busy trying to patch it.

Atomicity is important so that you don’t accidentally patch code while an injected thread happens to be running it.

Bonus chatter: Now, atomicity is still not bulletproof, because even if you manage to suspend all the threads, and prevent new ones from being injected, you still have the case where somebody calls Write­Process­Memory to modify the bytes of the process while everything in it is suspended.

And we saw earlier that Write­Process­Memory is not atomic, so it’s possible that a two-byte Write­Process­Memory writes the first byte, and then you do your atomic update of both bytes, and then the Write­Process­Memory finishes by writing the second byte, leaving a mishmash of your patch and the rogue one.

On the other hand, anybody who was using Write­Process­Memory to do code patching was already broken because of this lack of atomicity, so we are not introducing a new problem.

Furthermore, since the hot-patching space is reserved for Windows Update, an outsider that uses Write­Process­Memory to apply a hot-patch from another process is already breaking the rules. At this point Windows Update says, “Look, I can’t protect myself from this, and you’re in double-unsupported territory by the time we got here, so whatever happens is your problem.”

The post Why are we all worked up about atomicity when applying hot-patches if we can just suspend all the threads? appeared first on The Old New Thing.

What happens if you create the control with one style and then change the style later?

Don’t do that.

The Win32 classic static control was originally written in the early 1980s for Windows 1.0, and back then, people didn’t play funny games like changing a static control from text to bitmap. They barely had enough memory to add two numbers together!

The Win32 static control decides what it is when it is created, and it doesn’t listen to the WM_STYLE­CHANGED message to learn that somebody told it to change its clothes. Mostly because the WM_STYLE­CHANGED message wouldn’t exist for another decade. It assumes that the style doesn’t change for the lifetime of the control.

If you change the style on the fly, say, from image to text, what happens is that the control starts up and realizes that it’s an image, so it loads the image. And then when it is destroyed, it checks what it is, and hopefully it still says “You’re an image,” so it frees the image. But if you secretly changed it to “You’re text”, it says “Well, in that case, I don’t have to free an image,” and the image gets leaked.

This behavior has remained unchanged in the static control for backward compatibility. There are almost certainly programs that “know” about this behavior when they change an image static control to a text static control, so they “fix” the problem by deleting the leaked image. If the leak were fixed in the static control, this would result in a double-delete bug.

So just stay away from the electrified wire. If you need to change the style of a static control, destroy it and create a new one with the new style, or create two static controls (say, one image and one text) and hide one and show the other depending on which one you need.

The post You shouldn’t change the style of a Win32 static control after it has been created appeared first on The Old New Thing.

I started with SQL Server. In the documentation page Limit search results with RANK, it opens by telling you that higher ranks mean better matches, or at least that lower ranks mean worse matches, which is basically the same thing:

The CONTAINSTABLE and FREETEXTTABLE functions return a column named RANK that contains ordinal values from 0 through 1,000 (rank values). These values rank the rows according to how well they match the selection criteria. The rank values indicate only a relative order of relevance of the rows in the result set, with a lower value indicating lower relevance. The actual values are unimportant and typically differ each time the query runs.

It says that lower ranks are poorer-quality matches, so this implies that higher quality matches have higher ranks.

This “higher is better” is made more explicitly on the the RANK of a query result is a value that increases as the match quality improves: Query with Full-Text Search page:

The higher the rank value of the text or document in a row, the more relevant the row is for the given full-text query.

Okay, so that’s SQL Server. Good job, SQL Server.

The Windows Package Graph also has the concept of rank. And here the documentation is less helpful.

The rank parameter to the Add­Package­Dependency function is documented as

The rank to use to add the resolved package to the caller’s package graph. For more information, see the remarks.

If you go down to the remarks, the only mention of rank is

If multiple packages are present in the package graph with the same rank as the call to Add­Package­Dependency, the resolved package is (by default) added after others of the same rank. To add a package before others of the same rank, specify Add­Package­Dependency­Options_Prepend­If­Rank­Collision for the options parameter.

That’s nice, but it doesn’t tell me whether packages are searched from low rank to high, or from high rank to low. All I know is that if I want to be considered ahead of others of the same rank, I should pass this special flag; otherwise by default I am considered after others of the same rank. But it doesn’t say whether I am considered ahead of or after other packages with different ranks.

There is a “For more information” that takes me to the Using the Dynamic Dependency API page, but the only mention of rank is

When you call this API, you must pass in the dependency ID that was returned when you created the install-time reference, and the desired rank to use for the MSIX package in the process’s package graph.

So it tells me that I have to pass a rank, but it doesn’t tell me what the rank means.

Okay, maybe I can get a clue from another API in the Windows App SDK: The Rank property on the WidgetInfo class. Let’s see what that says.

An integer specifying the relative rank of the widget. Smaller values are ranked higher than lower values.

Okay, so I learn that ranks are relative rather than absolute values. But that second sentence makes no sense: It says that smaller values are treated differently from lower values. Huh? What’s the difference between a “smaller value” and a “lower value”? And what does “higher” rank mean anyway?

Unfortunately, the Widget sample doesn’t use the Rank property, so I still don’t know.

This is just another example of the principle that “The person who understands the feature the best is often the person least qualified to explain it.” They know what the rank is. They’ve been working with ranks for months. To them, ranks are so obvious and intuitive that they don’t need an explanation.

Bonus chatter: I contacted a colleague who works on the package graph, who explained to me how it works and also lamented how the information provided to the documentation team somehow got garbled along the way. (And put fixing it onto the backlog.)

The missing sentence is

Packages are searched in ascending rank.

In other words, at least for the package graph, lower ranks have precedence over higher ranks.

A process’s package graph is an ordered list of packages and is initially empty.

If the process has declared dependencies, then all of those packages are added to the package graph with rank zero, in the order described by static package dependency resolution algorithm.

Once that initial package graph is established, you can manually modify the graph by calling Add­Package­Dependency and Remove­Package­Dependency. When you add a package to the package graph, it is inserted into the graph after all the packages with lower rank and before all the packages with higher rank. By default, it also goes after all the packages with the same rank, but you can override this with Add­Package­Dependency­Options_Prepend­If­Rank­Collision, which will put it in front of all the packages with the same rank.

In the package graph, the rank is a signed integer, so you can use a negative rank to go in front of the static package dependencies.

Bonus bonus chatter: In the world of filter drivers, the applicable term is altitude, and the meaning is quite clearly spelled out:

The altitude is an infinite-precision string interpreted as a decimal number. A filter driver that has a low numerical altitude is loaded into the I/O stack below a filter driver that has a higher numerical value.

The post There are things with ranks, but it’s not always clear what the ranks mean appeared first on The Old New Thing.

The base Apple ][ was sold without a floppy drive. The only supported external storage device in the base unit was a cassette I/O port. Yet there was a database program for digitizing your phone list.¹ How did it do database stuff when the only I/O was a cassette drive? It could not programmatically start or stop the tape, or programmatically rewind or advance it.

If you took a listing of the program (which was written in BASIC), it began with a comment block saying not to edit any lines before line 1000. And then you saw your own telephone directory stored in DATA statements.² Followed by a bunch of dummy DATA statements. And then the program began.

Wait, how did your telephone directory show up as DATA statements? The BASIC DATA statement was a place for the program developer to store tables of precalculated read-only data, to be consumed by the READ statement at runtime. They shipped the program to you without your telephone directory in it, and yet somehow your telephone data ended up in the program.

That’s because the program used its own DATA statements as the memory for a database.

When it wanted to read from the database, it read the data via the usual READ command. And when it wanted to write to the database, it used self-modifying code to POKE the information back into its own DATA statements.

When you told the program that you wanted to save your changes, it told you to turn on the cassette player, and then it invoked the SAVE command to save the program to cassette. And since the program modified itself to contain your telephone data, saving the program also saved your data that was embedded inside it.

When you wanted to use your telephone directory, you loaded the program from cassette and ran it.

Now, the Apple ][ did have routines in the monitor ROM to save a block of memory to cassette, so it could have saved the database to tape in a more traditional manner. But that would have meant that when you wanted to use your telephone directory, you first had to load the program from cassette and run it, and then you had to set up the cassette a second time to load the database. Saving the entire program meant that the two load operations (loading the program and loading the data) were combined into a single cassette pass.

¹ This was back in the early days when the sales pitch for personal computers included “Organize your recipes!” and “Digitize your telephone directory!” Things that nobody ever actually did. (I don’t know how many people used it for personal finance, but it was definitely very popular for business finance.)

² At least, I think it was DATA statements. Maybe it was comments. But the same principle applies.

The post How do you implement a random-access database when you don’t have random-access external storage? appeared first on The Old New Thing.

Related reading: A ticket to the Windows 95 launch.

After a few of us arrived early at the Civic Auditorium for the launch event, we had to entertain ourselves until the doors opened. There was some speculation as to who the celebrity host would be, since it hadn’t been announced. One of my colleagues tried to sneak into what looked like a VIP tent.¹ I, on the other hand, went exploring.

I found an unlocked door that took me into the empty upper level of the main auditorium.

I took a seat and tried not to be noticed.

The stage was set up with a 10-meter tall mock laptop, screens to the left and right of the stage for projecting slides, prerecorded videos, or to get a better look at on-stage close-ups, gray curtains unobtrusively hung to shield from view what would turn out to be various surprises throughout the event, and various other desks, demo areas, and even an airplane cabin set.²

While I sat and took in the complexity of the stage, there was an announcement that they would be rehearsing the opening in one minute. The lights dimmed in preparation. The lid of the giant laptop closed very slowly.

About ten minutes after the announcement, the rehearsal actually began.

The laptop lid opened, and on the laptop screen, it looked like someone was signing into Windows 2000, and then the mouse clicked the Start button. This led to a video montage, and when the montage was over, a voice announced, “Ladies and Gentlemen, please welcome Patrick Stewart!”

Oh my goodness, Patrick Stewart is going to be the presenter for the Windows 2000 launch!

Mere seconds later, onto the stage bounded… a crew member wearing a headset pretending to be Patrick Stewart so that the camera and lighting crew could make sure they were properly positioned.

Okay, that’s the end of the rehearsal. The lights come back on, and the auditorium once again buzzes with the sound of equipment being moved and people discussing things.

I left the auditorium and went back to join the crowd of people waiting to get in. I didn’t tell them who the host was.

The event itself seemed to go off pretty much as planned. With the real Patrick Stewart.

Patrick Stewart had such a commanding presence. If he had come out on stage and announced, “It is the dawn of a new era: The era of lime Jell-O”, people would say, “Yeah, lime Jell-O, I need to upgrade to lime Jell-O.” But instead of trying to spark a new dessert trend, he talked about Windows 2000, reading words from a teleprompter that he almost certainly didn’t understand, but he made them sound great.

¹ My colleague eventually returned with a Commemorative Edition boxed copy of Windows 2000.

² The airplane cabin was used for a sketch that demonstrated mobile business computing. The demoer took their laptop on a plane trip, where they happened to sit next to a character named William Wentworth, portrayed by actor John O’Hurley, president of William Wentworth Worldwide. (He gave his email address as www@www.com.) The sketch demonstrated infrared file sharing and other mobile scenarios. Remember infrared file sharing? Of course you don’t.

The post Sneaking into the auditorium for the Windows 2000 launch rehearsal appeared first on The Old New Thing.

Building 22 began its life in 1982, when construction began on what was then known as the Koll Center Overlake business park. The building was owned and operated by The Koll Company, a commercial real estate company, and was scheduled to be completed in the middle of 1983.

In February 1991, Microsoft purchased the building from Koll, and by July it was occupied by the International Product Group.

During its time as a Microsoft office, Building 22 was believed by many to be haunted. The descriptions ranged from “it was creepy to say the least” to “the ghosts were quite benign” to “those ghosts were no joke”. Evidence included a phenomenon nicknamed “sick building syndrome” that made many people ill, elevator doors opening randomly, unexplained whistling or rattling sounds from the windows, occasional ghost spottings in the hallway, and at least one time that a car’s parking brake failed, causing the empty car to roll down the hill and collide with another car. Did a ghost release the brake? Who knows?

At the time, there was a Group Health hospital complex next door.² Somehow, the story got around that Building 22 had previously served as the morgue³ for the hospital, and I suspect that the ghost stories and the morgue theory developed in tandem. However, research by Microsoft’s own archives team could not find significant evidence that the building was ever a morgue, despite people insisting with certainty that their office was exactly where the morgue used to be.

Haunted or not, the new owners of the building intend to build apartments on the property. Were the ghosts sold with the building? Will the new apartment be haunted? We’ll let the future residents decide.

Bonus chatter: An old Channel 9 video introduces us to Building 22, ghost included.

Bonus bonus chatter: Another morbid reputation that Building 22 had was that it where teams were “sent to die”, meaning that they were transferred to the building as a final stop before the team was disbanded.

Some people nicknamed Building 22 “Hotel California” or “the black hole” because once you were assigned there, it was almost impossible to get out. You might get moved to another building, but somehow you ended up back in 22. One person who managed to escape quipped, “The longest two years of my career were the six months I spent there.”

Part of what contributed to the dreary reputation of Building 22 was that due to the steep slope of the terrain, half of the bottom floor was underground. One person who had an office on the bottom floor said that it was comfortably cool in the summer, but freezing cold in the winter.

Another quirk of the building was that there was bridge from the uphill side directly into the second floor. People on the first floor whose offices were in the shadow of the bridge nicknamed themselves “trolls”.

¹ Not to be confused with “The Village at Overlake Station”, a residential complex about four blocks from Overlake Village Station.

² The property was sold in 2009 and is now the Esterra Park development.

³ An alternate rumor was that the building used to be the psychiatric ward for the hospital, and the room above the atrium was allegedly the padded room for people at risk of hurting themselves. Some people reported hearing screams from the padded room area.

The post The Microsoft building that was reportedly haunted appeared first on The Old New Thing.