RELOAD!

meh, decisions... might pick up the ram first, there's a useful discount on amazon warehouse that may not hang around

I give my VM 8 gigs of RAM and 2 cores and it seems to do OK. If it bogs down, restarting Visual Studio usually helps more than anything.

[bruglesco/InventoryDesktop\‌​] 2 commits. 104 additions. 25 deletions.

[FreezePhoenix/XtraUtils] 2 commits. 2371 additions. 302 deletions.

I really need to bump up to 32 myself.

[rubberduck-vba/Rubberduck] 11 commits. 4 opened issues. 2 closed issues. 16 issue comments. 840 additions. 110 deletions.

not many options for 2x16gb ddr3 - really only crucial manufacture it afaict

in non ecc at least

You do have ECC on the raid machine though, ....right?

not an option :-(

Huh.

[rubberduck-vba/Rubberduck] DevulskyA opened issue #4216: WdKeydown is not being recognized as VBA constant

qnap ts-879. soho box, no ecc

I guess for my file server I had ECC support as one of the motherboard "must have" features list though.

got it for a crazy low price though and its been solid

yeah, a parity fail in the wrong spot would be... unpleasant

I build mine from components. Easier than finding a SMB grade server that was rack mountable.

ima do that next time around

meh, i'll leave this vm installing vs 2017 overnight

That reminds me, it might be time for me to start shopping for drives...

[rubberduck-vba/Rubberduck] DevulskyA edited issue #4216: WdKeydown is not being recognized as VBA constant and Wrong place declaration

hopefully tomorrow I can get back to the VB6 project!

ttgtb

night

Duck check: When working with a ViewModel is it bad to rely on the IsChecked menu item to be unchecked when another is selected?

[rubberduck-vba/Rubberduck] comintern created comment on issue #4216: WdKeydown is not being recognized as VBA constant and Wrong place declaration

This is why Naming Matters™.

oh c'mon. VBA gives you so much choices! We have vbNullChar, Null, vbNullString, vbEmpty, and for those with more discriminating taste, an empty or an error variant!

just choose whatever you like. they're all the same, man.

lol

I'm halfway surprised that VBA never introduced something idiotic like Option Null 0.

[rubberduck-vba/Rubberduck] comintern added label bug to issue #4216: WdKeydown is not being recognized as VBA constant and Wrong place declaration

[rubberduck-vba/Rubberduck] comintern added label feature-inspection-quickfixes to issue #4216: WdKeydown is not being recognized as VBA constant and Wrong place declaration

[rubberduck-vba/Rubberduck] comintern added label difficulty-02-ducky to issue #4216: WdKeydown is not being recognized as VBA constant and Wrong place declaration

[rubberduck-vba/Rubberduck] comintern added label up-for-grabs to issue #4216: WdKeydown is not being recognized as VBA constant and Wrong place declaration

[rubberduck-vba/Rubberduck] comintern created comment on issue #4216: WdKeydown is not being recognized as VBA constant and Wrong place declaration

[rubberduck-vba/Rubberduck] comintern edited issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

yeah, jives with what little I know --- legal personhood is pretty important.

I like the idea of moving to contributors, rather to a (non-person) organization

IOW if you want Copyright © 2014-2018 Rubberduck VBA, you register "Rubberduck VBA".

could be a NPO

I wonder if that's a service that the FSF provides.

Probably not. They're copyleft.

might be I don't grok OSS after all

Richard Stallman does not approve of Microsoft.

or I'm some kind of software communist

for the ducky!

ducks of the world, unite!

> We are Rubberduck

Speaking of which, if Rubberduck VBA becomes an NPO, it should register Rubberduck VBA as a trademark also.

Newtonsoft JSON.NET is OSS, right?

© 2018 Newtonsoft

Open source != without copyright.

the git history knows who did every single diff, no?

@MathieuGuindon Maybe. You can alter it or change authors on prior commits.

that OSS.SE answer is suggesting that good governance is to have each contributor's copyright notice in each file. is that for real?

My understanding is that if a contributor asserted copyright on a contribution, they would be under the burdon of proving authorship.

I think that's going way overboard. The license reads like this:

Failed attempt at emphasis is mine.

"appropriate notice" is subject to the legal jurisdiction in which the claim is made.

I don't know about Canadian law, but I believe that in the U.S. a non-revocable trust is considered a legal entity that can assert ownership and managing rights. The easiest way might be to establish a non-revocable, and then transfer copyright to that. The trust could stipulate that its name was "Rubberduck VBA" or something similar, and could basically spell out any rules about maintenance of the copyright that were compatible with the software license and applicable copyright laws.

fml

You and Chris could then just be trustees of the Rubberduck VBA Copyright Trust or whatever it was called.

I don't even know what copyright means in this context. when I merged the autocompletion feature, I chose to include that code in Rubberduck as a feature.. from that moment on, sure I wrote that code - but anyone else can now take it, tweak it, and PR it back. In fact that's precisely what I hope will happen at one point or another... as is the case for every other feature.. it's a collaborative effort. The code base as a whole, once compiled, is Rubberduck the product.

Drafting a trust is super easy - I've done a couple without a lawyer involved. You basically just have to notarize it and that's it. No reporting, no corporate or foundation registration, nothing.

FSF does manage copyrights.

fsf.org/bulletin/2014/spring/copyright-assignment-at-the-fsf

FML, they're freaking nuts though.

In order to make sure that all of our copyrights can meet the recordkeeping and other requirements of registration, and in order to be able to enforce the GPL most effectively, FSF requires that each author of code incorporated in FSF projects provide a copyright assignment, and, where appropriate, a disclaimer of any work-for-hire ownership claims by the programmer's employer.

and do we want to go there?

reading it, it feels more like giving the copyright to FSF, rather to the RD VBA contributors

Googling non-recovable trusts get me links about estate planning. Same thing?

If "Rubberduck Project Contributors" rather than "Rubberduck VBA" (the org) flies for everyone, I'd rather do that then

@this They're mainly used for that because they're cheap, easy, and legally binding. The purpose of the trust is irrelevant to its legal status.

@MathieuGuindon That sounds perfect to me.

I suspect the former will be less hassle; we do have GPL to cover the code itself.

Incidentally, regarding anonymous contributors, Canadian law says this:

and what of bugfix diffs?

@Comintern ..... how do we enforce that?!?

refactorings?

restructurings?

We don't know who did it but we know it wasn't you so we're gonna kick your ass for violating some guy's copyright

@this Presumably by proving the author can't be identified and that the author's work was copyrightable.

We don't know specifically who did it but we know it wasn't you so we're gonna kick your ass for violating a Rubberduck contributor's copyright

That's exactly what it means.

and that's exactly the goal "© Rubberuck VBA" means to achieve

so, "© Rubberduck Project Contributors" is it

The bugfix diffs and refactorings generally fall under the category of "derived works". They are copyrightable by the person that performed them to the extent that the derived contribution is significant and attributable to the author.

I mostly wonder how you infringe a copyright on a bugfix diff

So, for example, if you refactor something you could assert copyright on the structure, but the the actual code.

hey, doesn't GPL cover those?

@MathieuGuindon By a horrible quirk of fate?

that's the whole point of copyleft - to ensure that all those derived works stay GPL

@MathieuGuindon that also implies that it's the state that prosecutes on the behalf of the unknown victim.

A good metaphor of derived work would be if I painted a picture of say, a Campbell's soup can. I would have a copyright on the painting, Campbell's would retain rights to the design of the can.

(which is a good thing in that you don't need to drive and look pretty in front of a judge, then hand over a wad of cash to the prettier-looking guy in a pinstripe suit)

@Comintern right - you made a painting, not a can of soup

Yep, I refactored the code. I didn't write it.

@this I believe the intent is in the other direction - it prevents somebody else from attacking you with a copyright claim.

ok another one: subject A forks the project, clones it, builds it, then implements an inspection and makes a PR, that gets merged. subject A authored that inspection, thus owns the copyright on that code.

Wow, scanning back over this discussion it's really obvious that I work amongst lawyers, isn't it.

lol

@Comintern I don't follow. The burden of proof lies with the one asserting the copyright. If we're discussing a work from an unknown owner, that owner by very nature cannot be in a position to assert the claim.

@MathieuGuindon Yes. Although the GPL only grants license for them to fork the code and modify it if it remains GPL. That's the point of license attachment.

i.e. they don't need to PR it back, but the code needs to be out there

and I'm fine with that

@this Right, but it's a defense for a situation where Rubberduck contributors as a whole are, for example, sued by a third party asserting rights. RD doesn't have to trot out the person who wrote it, they can assert in defense of the copyright action that it was an anonymous third party.

> RD doesn't have to trot out the person who wrote it

^ that right there

@MathieuGuindon Exactly. That's actually the reason that Rubberduck VBA should be trademarked.

That would prevent a fork from calling itself Rubberduck VBA.

but then, who owns the trademark?

as in, which legal entity I guess

Anyone can own a trademark.

You just give permission to use it.

including a GitHub org?

Sure, you draft a legal document stipulating that it can be used in conjunction with the GitHub org's releases.

Remember, if you own a trademark you control how it is asserted.

well, FWIW, I saw an interesting model for multnational governance using each country NPO in a federation -- so we would have RD VBA Canada, RD VBA USA, RD VBA Australia, and so forth. Each is registered in their country as a NPO in respective jurisdiction. Those in turn draw up a contract with each other to establish a governance within that organization and transfer of assets.

"Rubberduck VBA USA, a Delaware LLC".

and boom, it can't be free anymore

or, we gotta sell cookies duckies

And file annual corporate reporting with the registering entity.

That's the main benefit of a trust when the only thing you want to assert is ownership.

and does it work in an international setting?

> we would have RD VBA Canada, RD VBA USA, RD VBA Australia, and so forth.

on the bright side, as a NPO we'd get reduced shipping costs with Canada Posts ..#swag

@this Inasmuch as an individual, yes.

I don't think Mat is exactly anxious to go to a board meeting, so....

Another option is a foundation, but I believe that in Canada foundation laws are mainly structured toward managing charitable contributions.

Wait, wut? I thought this was the board meeting.

It's been going on since around 2014 - SE is taking the minutes.

Doughnuts ran out a long time ago.

lol

Reduced postage rates in the States too. Sweet!

^ just the trademark

Gee

I wonder if there was a GoFundMe, would that get funded.

people like to fund swag for contributors but funding trademark?

funding mass-produced swag to sell for funding the trademark(s?) and NPO registrations?

i suspect that swag-for-sale would cost more money upfront than registrations.

yup

It's about $50 in the US.

@MathieuGuindon swag that needs to use the trademark, that isn't registered :-/

fml

We're capitalist's here. Don't let my profile picture fool you.

@Comintern ok I have to ask - what's the deal with commie guy there?

lol

LOL.

Comintern was my MUD\MOO handle back in the 80's and 90's. I picked it because it was pretty much always available.

I haven't read the history, but in most places. An unregistered trademark is fine. It's still enforceable, you just need to have clear evidence of the mark in use, and clear evidence of the market segments that it is in.

so status quo is fine then

#lost

Registration is a step that codifies when your trademark was "commonly known".

The entity matters though. Just like that monkey in the selfie couldn't enforce copyright.

Absent registration, you can assert a trademark, but at least in the U.S. you need to show that it is inseparably linked with the mark that it represents.

ok quick, think "Rubberduck"

VBA?

lol

@Comintern you're bringing back awful memories of when I had to do this for an old company of mine. I got a registration in Australia, and the US, but it was a PITA.

mostly because of US?

In connjunction with VBA, Rubberduck has a reasonable unregistered TM claim. RD would lose a claim on TM of Rubberduck in a general context because, well vulcanized rubber representations of water fowl.

(more like, it's a PITA regardless of where you are)

You can look and dress like Colonel Sanders, but don't try to sell fried chicken.

@MathieuGuindon well, any foreign country would have added to the confusion. It wasn't the fault of USPTO. It was more that it was 2 completely different processes, and sets of terminology etc.

"Rubberduck" could be reasonably claimed too IMO

I would think so.

for software

there's already one on some shady USB hardware I think

@MathieuGuindon Rubberduck debugging is close to having overlap in terms of industry classification

@ThunderFrame except it's "Rubber duck debugging"

or "RubberDuck"

but "Rubberduck"?

meh

Right. I could start a Rubberduck Italian Restaurant and be in the clear (other than the horrible name for an Italian restaurant).

And, given the public nature of this chat, we've already waived client-attorney privilege in any discovery motion. Public chat isn't the best place to discuss?

@MathieuGuindon We can cross that bridge when we figure out how to get our hooks in the debugger.

I'll start a Rubberduck bathroom furnitures shop just in front of your restaurant

@Comintern LOL

OMG

@ThunderFrame On the contrary - it's the best place for discussing trademark claims. It reinforces them.

so searching for "Rubberduck VBA trademark" should point right here now?

Judge, I'd like to present for exhibit this printout of 395,394,139 pages transcribing the chat history minutes of board meeting that is continually held and continues to be held even at this moment that conclusively demonstrate that the trademark and copyright has been continually and unfailingly asserted since 2014, the inception of the project!

LOL

I think you mean the minutes from the board meeting.

@this notice the frequent, inconsistent miscapitalization of the term, and occasional substitution of the second U for an I.

Thus the claims of multiple trademarks in our action.

Speaking of hands in stuff. The TypeLib offset that gives us the Stream of p-code and source code. We seem interested in grabbing the source code, as to avoid a write to disk, but what if we grabbed the p-code instead? Wouldn't that give us a stream of tokens, and avoid the need to parse source code at all? Sure, we need to understand the p-code, but Wayne hints that that is easy compared to excode.

I'm not sure the p-code is aware of things like white-space though, is it?

not sure Wayne's "easy" is on the same scale as mine though

@Comintern that's why the VBE nukes it every time

@Comintern it must be, it can completely recreate the source, if you remove the source from the binary.

Huh.

So it's like it's own pdb file too.

private                   foo                    as                       string

@ThunderFrame are you referring to decompiling?

Private foo                                      As String

^ that's the VBE being deliberate here

I mean, I don't think the space between foo and As is anywhere in the p-code

I have a sneaking suspicion that the reason the increment and decrement operators aren't in the language is because the developers couldn't figure out how to get the VBE to stop turning them into foo + + and foo - -

ha!

@this decompiling the p-code, not the excode. The p-code decompilation is semi-documented in a GitHub repo. The excode, only Wayne knows. IIUC, MS will let you sign an NDA to read the p-code, as antivirus companies need to inspect the p-code, because the source can literally be anything, and as long as the VBE is the same version/bitness, the VBE will ignore the source and rebuild the code from p-code.

hmm. I asked primarily because i'm not sure where the "compiler junk" are at.

but sounds like it's close to where p-code is.

@Comintern but the indenting whitespace, I believe, is maintained by p-code. The excode, you lose whitespace, you lose module-level variable names, and IIUC, you lose calculated constant formulas, and maybe a few other things.

we are talking about the fact that we can figure out a variable name and whatnot, right?

@this ?

That's the same as symbol files IIR.

Wayne provided an example here: everythingaccess.com/mdeprotector_example.htm

@ThunderFrame hmm so it would be some kind of NOP word with the number of spaces??

@this the p-code is what a line gets converted to as soon as you enter it, the VBE then converts that p-code back to a pretty-printed line (hence losing the whitespace that Mat showed)

I've always thought of it more as a token re-writer.

So the p-code is a one-for-one representation of the code, but as identifiers, opcode and tokens.

so the "p" in the "p-code" stands for pretty code? Gotcha

In theory, antlr could emit pcode.

;-P

@ThunderFrame and the editor makes it red if it doesn't know what to do with it

I've dabbled with the GitHub project, but it's effectively a god procedure, and it's python. I got an understanding of the layout though. Symbol tables, references, opcodes etc.

The editor apparently does whatever the hell it pleases.

^

@MathieuGuindon yep, or transparent if you use destructive force and use a reserved word and blow up the VBE!

lol

i wonder if reading p-code would make it easier to parse stupid enum names.

I'm not suggesting p-code analysis as a short-term solution. Just saying it's already a tokenized representation of the code, complete with identifiers etc. It would be faster than parsing/resolving.

@this that's the only way to parse unparsable source code.

@ThunderFrame hmm not sure we get to avoid not resolving?

@this Probably not, and the enum names should work now.

@this well, some of the resolving

I imagine it's more like that ^^^.

@Comintern nope, parser error for this:

Public Enum Foo = 42 : Bar = 21 : End Enum
    Foo = 42
    Bar = 21
End Enum

the pretty printer removes the brackets so RD can't possibly know there's supposed to be brackets there.

That's a PDF file, and it contains enough information to assert any debugger that can read it as the appropriate symbol.

@this Ahhh.... ThunderCode.

:-)

My guess is that the p-code wouldn't have that either - it would only store the abstract symbol with whatever the "canonical" representation was. That may be the reason that the brackets disappear - the symbol table doesn't know to store them, but it can differentiate them because they have different entries in the symbol table.

This is also fun code, courtesy of Mr. ThunderFrame:

Private My Variable As String

Public Sub Test()
    Call My Variable
End Sub

Debug.Print My Variable

Public Sub My Variable()
    With My Variable
        Debug.Print My Variable
    End With
End Sub

wut

this compiles and run.

I know, just not how. it's like ...magic.

O_O

That's some serious voodoo sh!t.

non-breaking spaces I get

but that Debug.Print beats me

and ...no, I don't get any of it, that Private field shatters everything

unless one has one nbsp and the other has two, or something like that

put it up on puzzling.se

Note to self: Replace the \s expressions in the indenter Regex's with \x20.

given this code in Module3:

Option Explicit

Public Sub Foo()
    Debug.Print "Hello World"
End Sub

The p-code is the non-selected area, and the selected area is the compressed source:

sure, it looks like more p-code than source, but that p-code section contains lots of metadata

So you could literally put whatever the hell you want in as the compressed source?

note the symbol table toward the end of the p-code block

@Comintern yep - it doesn't even need to be compressed

'Nothing to see here - All your codez are belong to us

Everyone is doing their source code obfuscators wrong.

LOL

yup

@ThunderFrame out of curiosity - why are there apparently random dots in the words? (like Debu.g and W.orld?

"Why am I getting a macro warning? This project contains no code..."

> It is surprising that malware authors are not using this trick more widely. pcodedmp.py - A VBA p-code disassembler

> You've been rubberducked

gosh no, now that looks like a malware that nukes your VBA code

@ThunderFrame IKR?

@MathieuGuindon RD Inspection: Your code is not what you think it is.

ouch

I'm going to start posting stuff like this on SO [vba] questions:

well, it never is, is it

'Do this:






'Done.

' step 1:



'step 2:



'...





'...profit.

hmmm interesting...

wonder if that also means they plugged the immediate hole there....

ha, feels like it

@this that's the compression at work

^^^ Triggers inspection "Consider renaming variable ''"

nah, the author says he doesn't have 2016 64-bit.

Probably just need to deal with boundary alignment

TTGTB

@this I can't imagine that would be horribly difficult - just compile the same source in both 32 and 64 bit and examine the boundaries.

@MathieuGuindon night

night,mat

@Comintern well, no, but you kind of need an access to the 64-bit Office, no?

or he doesn't have enough friends running Office 2016 64-bit. :p

Sure, but we apparently have 38 contributors in the last year so that can't be hard.

I'd just spin out another VM.

yeah

Is it just me, or is GitHub slow as hell tonight?

despite 32-bit being more prevalent, we really ought to test under 64-bit more. It has extra functions, types, typehints and TypeDefs, that won't otherwise get tested.

ok, so pluralizing that made the differences sound greater than they actually are.

I'm running it now, as evidenced by my :facepalm: issue...

My Python is sketchy, but I might be able to port that. Lots of delegates.

This always slays me: from __future__ import

@Comintern needs an OOP rewrite, iirc

Yeah, but my general rule is that once it works in the target language, it's easy (easier) to refactor.

I'm amazed at how tightly coupled it is to the type info.

# The following idiocy is because Microsoft can't stick
# to their own format specification

@Comintern the binary TLB or the TLB composition?

The composition.

I guess it makes sense though, in that the vtables need to build based on the type description.

LOL - I like how the base element of the token table is <crash>.

VB_Invoke_PropertyPut? Do the VBA tlbs support DispId.PropertyPut?

Their offset is wrong in this commented code.

# argTypeName = getName(indirectTable, identifiers, argType + 6, endian, vbaVer, is64bit)

I might need to PR back into this.

I think I have the breaking edits down to 2 files. Hopefully I can figure it out with sleep and a clear head tomorrow.

Night pond.

[rubberduck-vba/Rubberduck] DevulskyA edited issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

[rubberduck-vba/Rubberduck] DevulskyA created comment on issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

> I am using Rubberduck v2.2.0.3505-pre

[rubberduck-vba/Rubberduck] DevulskyA edited comment on issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

[rubberduck-vba/Rubberduck] DevulskyA edited comment on issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

[rubberduck-vba/Rubberduck] DevulskyA edited comment on issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

All the best for the wedding ahead @M.Doerner

[rubberduck-vba/Rubberduck] Vogel612 edited issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

Umm...@MathieuGuindonis this proposal caters for the under the bus worst case?

[rubberduck-vba/Rubberduck] MDoerner created comment on issue #4216: UndeclaredVariableInspection quick fix places declarations in the wrong place

> The quickfix bug is exactly issue #4215.

Nvm I understand the trademark assert. Just proving the evidence, gotcha.

@this do you remember Wayne saying something about Enums being kept somewhere other than in the module/class module? Where does the TypeLib keep them? At the globals level?

My chat search foo is clearly not as strong as yours

I noticed that you have to type in the username just at right speed. Too slow, they get all wrong Waynes and won't let you select the right Wayne. If you don't let it select, it will also select the wrong Wayne.

@this IKR, the time of day seems to make a difference too. But the search terms seem to be order of use specific. Which makes it hard.

Our own internal training website won't work with it, and yet corporate IT insists on making IE (not even Edge) the default browser on everyone's machine. Every time I reboot the default browser gets reset by policy.

@ThunderFrame The TypeLib keeps them at the same organization level as a module or interface. TYPEKIND.TKIND_ENUM

Same as structs.

@Comintern I see - I can't seem to find evidence of them in the p-code - might need to do some more testing.

well, not at the module level in which they're declared

@FreeMan I used to work somewhere where they paid for a Netscape license, and then had the audacity to make us use it!

I'd guess they'd only link into the symbol table for the enumeration. Pretty sure that enums always have project scope too.

@Comintern As Wayne mentioned in next line, we can find them but only via a reference from other TypeInfo.

I wonder if the enumerations and constants that aren't referenced/used are simply dropped out of the compilation.

It wouldn't be able to recreate the source then.

True.

yeah, next spot to look is in the project stream - I suspect they'll be there.

Constants can go anywhere in a TypeLib apparently. IIR even the ones in the reference projects we serialize for tests have different organization patterns.

@Comintern yes but recall from few days ago, they don't need to come up.

a const compiled in a body of interface just won't exist after the compilation.

True. I think the COM spec has slightly stricter rules than the MIDL spec.

also when tweaking OleWoo, I observed that the typedef have to be defined in a certain way. Otherwise, OB won't display constants correctly.

you can see it in the Scripting type library - their constants are borked up with names like MIDL_......

I think I'm ultimately going to have to put a bounty on this one:

@this I ran into something odd with typedefs in the VBE lib too- they apparently don't need to declare a GUID either. LONG_PTR stores its GUID in a custom attribute instead.

hmm. can a typedef have a guid?

I assumed the GUID in the custom was just a key to get to the custom data, no more.

MIDL specs doesn't list uuid as one of its valid attributes for the typedef

Yes. The ones in mso and stdole do IIR.

In the actual TypeLib it's included on the structure for all top level elements.

yes but uuid ≠ custom's key

Ah, I follow now.

FWIW, we have them generated in our IDL, too and I don't specify them at all

I understand the MIDL spec to mean that custom can be anything the declaring type wants it to be.

yeah and it'd be only useful to the consumers that understand what to do with it.

in our case, we get some attributes useful for COM interop, IINM.

[rubberduck-vba/Rubberduck] ThunderFrame created comment on issue #1057: Parser bug with Rem statements immediately followed by special characters

Right. Or internal consumption by the declaring library.

yeah

@Duga I'll need to add that in the indenter.

@Comintern I'd forgotten about comment arrays: Rem(1 To 500)

in this situation:

[
  uuid(E07C841C-43F0-3B33-B105-9B8188A6F040),
  version(2.2),
  helpstring("Rubberduck AddIn"),
  custom(DE77BA64-517C-11D1-A2DA-0000F8773CE9, 134283886),
  custom(DE77BA63-517C-11D1-A2DA-0000F8773CE9, 2147483647),
  custom(DE77BA65-517C-11D1-A2DA-0000F8773CE9, "Created by MIDL version 8.01.0622 at Mon Jan 18 21:14:07 2038
"),
  custom(90883F05-3D28-11D2-8F17-00A0C9A6186D, "Rubberduck, Version=2.2.6772.40445, Culture=neutral, PublicKeyToken=null")

]
library Rubberduck

the first 3 came from MIDL itself. The last one came from .NET.

oh, hai, Rubberduck from 2038!