Google v. Oracle Perspective: Google’s Android ‘Cheat Code’ was to Copy Oracle’s Code

“Section 102(b) of the Copyright Act does not create any new standards by which creative expression should be denied copyright protection. It merely says that copyright for the expression doesn’t extend to the ideas, methods of operation, procedures, and processes that may be embodied in the protected expression.”

Google v. Oracle - two months, the Supreme Court will hear the oral argument in the long-running Google v. Oracle software copyright case. At issue is the availability of copyright protection for computer programs and in particular the copyright protection of code in Oracle’s Java platform, which Google admits it copied for its Android operating system without obtaining a license. Google also claims its commercial use of that code in competition with Oracle is protected under copyright law’s fair use doctrine, but that is a subject for another day.

If adopted by the Supreme Court, Google’s arguments would undermine the Constitutional purposes and specific Congressional intent in enacting the Copyright Act, and along with them the fundamental incentives for new creative expression in software, a building block of so many consumer and industrial products. To better understand how, it helps to start at the beginning: Apple’s groundbreaking release of the iPhone.

Apple Innovated and Google Copied

In January 2007, Apple CEO Steve Jobs announced the first iPhone. It was a revolutionary product that combined cellular calling, email, touch-screen web browsing, music, and other apps that either didn’t exist on the then-dominant Blackberry handheld, or which required the combined capabilities of several different devices.

Until then, the Android operating system under development at Google was a Blackberry clone with a few more features. After Apple unveiled the iPhone, Google scrapped previous plans because it knew it was in trouble, shrewdly perceiving two realities:

  • Google’s data-scraping, advertising-based business model depended on massive numbers of people using its services on the web, yet users would increasingly tap the internet via mobile devices.
  • Competition among mobile devices would pivot on functionality, including the availability of third-party apps.

Google and its business partners, such as Samsung and Motorola Mobility, which it later acquired, copied many operational aspects of the iPhone. That led to extensive patent litigation. But copying Apple’s product didn’t solve all of Google’s problems. Today we take for granted that there’s an app for everything. That wasn’t so in the early days of smartphones. Apple had the early lead in apps available for its platform. Copying Apple’s code would leave Google in second place in the app market. It needed an artificial boost to catch up with Apple – a “cheat code” like the ones that give players an artificial and unearned advantage in video games. Except this was in real life and billions of dollars were at stake.

The Java code developed by Silicon Valley server and software pioneer Sun Microsystems, which Oracle acquired in 2010, was the answer Google needed.

Java, unveiled in the mid-1990s, became widely used thanks to its “write once, run anywhere” functionality that let programs run across computers based on various operating system and chip platforms. Java was easy to use and well known to programmers, who could quickly write new apps for a Java-based environment. Making Android into such a computing environment would let Google offer new apps —and thus make its platform more competitive — much faster than it otherwise could.

But Google didn’t license the code it needed from Sun, whose terms would have preserved “write once, run anywhere” and prevented Google from keeping Android proprietary. Google’s business couldn’t succeed under those strictures. It’s important to remember that Google doesn’t make and sell hardware as Apple does. It relies on its platform to collect data from users and show them commercially valuable targeted ads. If other companies could offer devices that ran apps written for Android, Google would have lost control, users, and money.

To catch up with the iPhone then, Google needed to copy key elements of Java — namely, its declaring code that programmers use to allow their apps to access pre-written code, a key efficiency shortcut. Google needed to play catch-up without taking a Java license — as some of its own technicians concluded it needed to — so it could keep Android proprietary. Every argument Google has made in the ensuing litigation has been a post-hoc rationalization of those business decisions.

The Supreme Court has seen this type of behavior before and had little patience for it. The Grokster and Aereo cases both involved companies that tried to gain a competitive advantage by infringing copyright. While the particulars of the copyright law that were at issue varied, they both involved companies that tried to engineer their systems in a way they hoped would allow them to use others’ copyrighted works without a license, in competition with the copyright owner, for their commercial advantage. In the present case, Google is trying to engineer the law to fit its copying. On the business side, its strategy already worked. The Android platform outsells Apple and Microsoft combined. And with annual revenue over $160 billion, any damage award in this case will be no more than a one-time hiccup on Google’s balance sheet. It is for the Court to decide whether to apply some measure of accountability for Google’s copying or to excuse it and weaken copyright law even more.

Copyrightability of Java’s ‘Declaring Code’

Google copied more than 11,000 lines of Oracle’s Java code to build Android. Specifically, it copied the “declaring code,” instructions that describe pre-written programs in Java. There is no dispute as to whether the copying occurred, or that it was infringing—the first jury found that it was—instead, the question is whether it was otherwise excused.

The U.S. Copyright Act protects original works of authorship. Computer code qualifies as a “work of authorship,” since the statute defines a computer program as a “set of statements or instructions” that are used “to bring about a certain result.” As the Solicitor General reminded the Court, “petitioner [Google] conceded below that both the 11,330 lines of declaring code that it copied and the SSO of the Java Standard Library satisfy the originality requirement for copyright protection.” (See page 16). That did not stop Google from later contradicting itself, trying to contest that point before the Supreme Court. (See page 10).

But Google doesn’t want to talk about that. Rather, its briefing reveals a strategy of conflating the copyrightability of the original code at issue with that code’s function. Those familiar with copyright principles will immediately recognize the error in that reasoning. Copyright protects creative expression in original works of authorship, including computer code. Copyright does not protect functions, which are the domain of patent law. This is the idea/expression dichotomy, a foundational doctrine that articulates the boundary between what copyright is designed to protect — expression — and what it does not — ideas, systems, and methods of operation. By trying to characterize code as the function it performs Google misapplies the law to reach the incorrect result it desires.

Google hinges its argument on a novel interpretation of the Copyright Act—specifically, Section 102(b), the provision that codifies the idea-expression dichotomy. Section 102(b) provides:

In no case does copyright protection for an original work of authorship extend to any idea, procedure, process, system, method of operation, concept, principle, or discovery, regardless of the form in which it is described, explained, illustrated, or embodied in such work.

Google now zooms in on the phrase “or embodied in such work,” claiming that because Oracle’s otherwise-copyrightable code embodies a method of operation, 102(b) denies copyright to the expressive code.

To understand why this is wrong, we need only look at the plain language of 102(b).

The construction of Section 102 is well-established. Subsection (a) sets the requirements for copyrightable works: they must be (1) original (2) works of authorship, and (3) “fixed in any tangible medium of expression.” Subsection (b) is the flip side, stating that copyright protection established in 102(a) doesn’t extend to ideas, procedures, or methods of operation.

Google seizes on the last five words of the section: “or embodied in such work.” It argues that expressive works that embody an idea can never be protected. This flips the text on its head: under Google’s reading, 102(b) does not just limit the reach of 102(a) to preclude ideas from protection, but undoes 102(a) to deny protection to the expression itself. Google’s approach would change Section 102, the foundation of the Copyright Act, from a pair of complementary provisions into a section at war with itself. This is the core of Google’s cheat code.

Of course, virtually all copyrightable expression embodies some idea. And computer programs are by their nature designed to produce a functional outcome when the code is processed and run. Congress even defined computer programs as works that “bring about a certain result” — copyrightable expression with an uncopyrightable functional aftermath. If function alone were enough to render the expression unprotectable, copyright for computer programs, indeed all of copyright would be swallowed up.

As Nimmer on Copyright, a widely cited treatise on copyright law, confirms, it “would, then, be a misreading of Section 102(b) to interpret it to deny copyright protection to ‘the expression’ of a work, even if that work happens to consist of an ‘idea, procedure, process etc.’” (1 Nimmer on Copyright §2.03).

Analogies in the Semiconductor Chip Protection Act

If that were not enough, the structure of the Copyright Act and legislative history further dispel Google’s claim. The Copyright Act speaks of embodiment repeatedly and in a variety of contexts:

  • Architectural works can be embodied in buildings, plans, and drawings.
  • Audiovisual works can be embodied in films or tapes.
  • Musical works can be embodied in sound recordings and “phonorecords” — such as LPs, tapes, CDs, DVDs, and digital files.
  • Works can be embodied in transmissions and material objects.

In none of those cases is the copyrightability of a work extinguished by the characteristics of “embodiment.”

Perhaps most tellingly, the Semiconductor Chip Protection Act of 1984 included a faithful recitation of the text of Section 102(b) as it applies to “mask works,” the series of images that together describe layers of a semiconductor chip (codified at 17 U.S.C. §902(c)).

Given that this enactment came just four years after the statutory changes that provided federal copyright protection to computer programs, it is particularly instructive. At least as much as computer programs, mask works have inherently functional purposes. As with computer programs, Congress saw no contradiction in providing copyright protection for their creative elements: code in the case of programs and design in the case of microchips.

House Judiciary Committee Report 98-781 on the SCPA is a conclusive rejection of the novel and unsupported position Google has put forward. On page 19, it specifically addresses the meaning of section 902(c), stating:

Section 902(c) distinguishes the subject matter of the Semiconductor Chip Protecting Act from the subject matter of the patent laws. In this regard, section 902(c) parallels section 102(b) of the Copyright Act.

It’s that simple. Section 102(b) does not create any new standards by which creative expression should be denied copyright protection. It merely says that copyright for the expression doesn’t extend to the ideas, methods of operation, procedures, and processes that may be embodied in the protected expression. Those are the purview of patent law.

And that’s why Google insists on trying to conflate the expression at issue in this case — Oracle’s declaring code — with the function that code performs when it’s run. A ruling for Google would undermine the protection for all computer programs, because they all ultimately perform a function.

Conversely, the Court can affirm that the code is copyrightable without disturbing precedent and, despite the usual apocalyptic predictions by some of Google’s amici, without broadening the scope of copyright.

Google Crossed the Line

Google, like Apple before it and Microsoft after it, is free to write its own declaring code for its mobile platform. That code can even achieve the same function as Java’s code, so long as Google writes its code independently. But Google’s business decision to copy the code as a shortcut to close ground with the innovative iPhone crossed the line into infringement.

Image Source: Deposit Photos
Copyright: AndrewLozovyi
Image ID: 236462792


Warning & Disclaimer: The pages, articles and comments on do not constitute legal advice, nor do they create any attorney-client relationship. The articles published express the personal opinion and views of the author as of the time of publication and should not be attributed to the author’s employer, clients or the sponsors of

Join the Discussion

19 comments so far.

  • [Avatar for Trip Richert]
    Trip Richert
    September 26, 2020 08:58 pm

    “Declarative code” as you refer to it, doesn’t do anything. The declarative code is just names. It is just a spec, not an implementation.

    Google copied the declarations. Not because they are particularly good. But, because Google reasonably wanted to be able execute existing code that Oracle had no rights to.

    Most college students write some Java code. It’s a common programming language. In this lawsuit, Oracle is claiming an exclusive right to control who can implement tools to run any Java program written by anyone in the world. Running the Java code I wrote in college is impossible without writing an implementation that matches Sun’s (now Oracle’s) declarations.

    This kind of copy right abuse by Oracle is unprecedented. It is anti-competitive. It’s absurd.

    you say “computer programs are by their nature designed to produce a functional outcome when the code is processed and run”, but the declarative code doesn’t execute. It doesn’t run. When the code is compiled to byte code to be interpreted, the declarative code translates to nothing. It doesn’t do anything.

    The user’s code does things. The library implementation (like the one independently developed by google) does things. Implementations run. “Declarative code” does not execute. Declarations are just the names the user code uses to refer to the library implementation code. That is all.

    A ruling in favor of Oracle in this case would undermine the copyright of all developers. Language API and library API are indistinguishable. If I want control over rights to my own software, I would have to write my own language, even design my own hardware, because, by Oracle’s reasoning, my rights to execute my own programs are controlled by the copyright of anyone who writes anything I interface with, even if I or someone else is willing to entirely and independently rewrite their implementation.

  • [Avatar for Raymond Van Dyke]
    Raymond Van Dyke
    August 10, 2020 08:33 am

    Had Google merely threw a thousand coders at the problem in a clean room protocol, and they solved the problems using virtually or actually the identical code language, then they would have a better argument than just taking the code and calling it free to use. And the copying of only a tiny part of the code does not insulate Google from infringement. In the Supreme Court Harper Row decision, small portions of Gerald Ford’s autobiography were used inappropriately, the key portions. That was considered a taking, which is what happened here. The merger doctrine should not extend to wholesale copying.

  • [Avatar for Markus M Mobius]
    Markus M Mobius
    August 9, 2020 02:40 am

    APIs are different from standard code because they provide the glue between programs. There is no analogy to this with books or movies.

    If Oracle or any other platform owner create an API they want other developers to write code for it. This code belongs to the respective developer. However, it is extremely costly to later rewrite the code for a different API.

    Assume for example, that the platform owner suddenly increases the access price for the platform. Given the high costs of changing platforms (changing APIs) the 3rd party developer would be locked in. Be allowing others to reimplement this API glue layer, this lock-in is avoided. Of course, platform owners do not like this: they would prefer that developers remain locked to their platform. But this just reflects the balance between trying to profit from 3rd party developers (after all, why did the platform owner open the platform in the first place by creating an API) and exploiting them. Sun/Oracle benefited from others creating code for their platform – but does this entitle them to effectively control this code forever?

    Finally Ryan’s question on Oracle/SQL is spot-on: the Java API did not develop in a vacuum. It has obvious inspiration from the C standard library and countless other APIs. Before Oracle’s lawsuit it was a broadly accepted paradigm that APIs can be re-implemented.

  • [Avatar for tricorn]
    August 8, 2020 10:33 am

    You don’t even come close to discussing Google’s actual defense. At issue is whether a valid copyright on source code extends to the software interface that is “described, explained, illustrated, or embodied” in the source code, which means you have to determine if the interface, the Java API itself (independent of any source code; that abstraction that is described by the Java API Specification) is a “system or method of operation”, to which copyright cannot be extended under 102(b).

    Copyright does not protect function, such as the behavior of a computer program. The function of the Java API, in any implementation of the API Specification, is to properly respond to a programmer’s class references and method calls.

    Google did not copy the actual “declaring code” from Oracle. Google copied only the names and hierarchy of the Java API command class package, class, and method hierarchy, which is required for any implementation to function correctly. There is only one way in Java to write the public declarations for that specific interface. Any Java programmer would write the exact same declarations in any implementation of the Java API.

    Missing from your discussion is any mention of merger, Baker v Selden, Sega v Accolade, Sony v Connectix, or Lotus v Borland. Without that perspective, your arguments and conclusion are fatally flawed.

    There is absolutely no danger of “all software” losing copyright protection because a tiny percent of the lines of code in an API written in Java are not protected by copyright. That is a foolish conclusion based on a terribly flawed set of arguments by the Federal Circuit, which you seem to have fallen for.

  • [Avatar for Chris Rankin]
    Chris Rankin
    August 8, 2020 10:32 am

    No, this is all nonsense. The “declaring code” that Google has reproduced is merely stuff like this:

    package java.lang;

    public class Math {
    public static int min(int a, int b) {
    // DO SOMETHING! Write me, Steve!
    // (BTW, this line is called a “comment”. I think comments ARE copyrightable 😉 )

    This code merely “declares” that there is a function called “max” in a class called “Math” in a package called “java.lang”, and that it expects two (native) integer types in and returns one native integer type out. That’s all, It’s up to you to write the code that performs this function, and whatever you come up with is copyrightable. But there’s only ONE way to write that particular declaration in Java, which is why 102(b) should apply to it.

    Google didn’t use any of Sun / Oracle’s implementation code, of course. No-one disputes that the implementation code is and should be copyrightable either.

    If you changed this function’s name to “MAX”, or the class’s name to “Maths” or make any other change to the declaration then it becomes unusable to existing Java code, i.e. it doesn’t work and people’s Java programs would break.

    Talk about “clean rooms” here is irrelevant too. Google actually started with Apache Harmony code, not Sun / Oracle’s code, and even Oracle acknowledges that. But you would still emerge from a “clean room” with the exact same declaring code, again because there’s only one way to express those declarations in Java. And so you would still be infringing copyright unless 102(b) also applied.

  • [Avatar for marsilies]
    August 8, 2020 10:03 am

    This article doesn’t mention merger, which is central to Google’s first question. The Second Circuit says merger happens “in those instances where there is only one or so few ways of expressing an idea that protection of the expression would effectively accord protection to the idea itself.”

    Google’s argument is that the declaration code lines for the public methods in the Java API source code are not protected by the copyright for the source code, not because those declaration code lines perform a function, but because they’re the ONLY way to implement the API in question, the Java API, and its function. By affording protection to those particular declaration lines (not the only declaration lines in the source code), it effectively accords protection to the API itself.

    An API, being an interface, is something functional, and as a functional abstraction can only be protected by patent (as parts of it are), not copyright.

    Google’s argument has nothing to do with the source code overall “embodying” the API, but that certain parts of that expression are essential to the API. One can’t write code that properly calls the API without using the correct method, class, and package names in the correct order, and one can’t write an alternate implementation of the API that can run code that calls it without also using the correct method, class, and package names in the correct order. The way of expressing the correct method, class, and package names in the correct order within the code itself is so limited as to be merged with it.

    To not address the question of merger is to essentially leave Google’s first question unaddressed.

  • [Avatar for David Sutherland]
    David Sutherland
    August 8, 2020 07:35 am

    Google’s declarations came from Apache Harmony – an Apache licensed implementation of the JVM. They didn’t need any other license. Those 11,000 lines (so many?) are a mere 0.08% of the total code (around 13,0000,000 lines) that actually implements the API – so suddenly the big theft narrative looks sensationalist and rather silly. The declarations are a tiny subset of the API – labels for functionality.

    Google could also have bought a text-book on the Java API and worked from there – all the declarations are documented so that programmers can write Java code. Or Google could have read the docs on Oracle’s site that require no license to access. You do understand that programmers use those declarations to create their own works, right? That they act like words in English?

    Copyright of an API is effectively an automatic, extremely long-lived patent on a technology, without any of the protections and novelty requirements of an actual patent. The PC industry wouldn’t exist today if copyright could protect software interfaces!

    Your claim that “there is no dispute” that the jury in the first trial found the code to be copied and infringing is untrue. The jury was hung on the issue of fair use, and their verdict that Google’s declarations infringed at all was rendered moot when the judge sensibly found that API declarations cannot be protected by copyright. No dispute? Some honesty, please.

    The CAFC disagreed but there are many good reasons why the case is now in front of the Supremes – such as the CAFC’s total incompetence on matters of copyright law, and their unconstitutional rejection of the second jury’s “fair use” verdict. Until SCOTUS rules none of us know if the API can even be protected by copyright, let alone if Google infringed – it’s a bit early to declare anyone’s guilt.

    Here’s some more Nimmer quotes for you, since you have so much respect for his opinion on this topic:

    The Federal Circuit’s Decisions Conflict with Baker v. Selden
    The Federal Circuit’s Decisions Misconstrue the Copyright Act
    The Federal Circuit’s Decisions Revive and Exacerbate Circuit Splits on Copyrightability, Merger, and Fair Use
    Reversing the Federal Circuit’s Oracle v. Google Decisions Maintains the Coherence of the Intellectual Property System and Will Restore Peace and Clarity to the Computer Software Industry

    This is copyright authority David Nimmer (and associates) slaughtering Oracle and the CAFC. He filed an amicus brief in support of Google as he actually understands the issues involved. It’s a great read with very well argued points.

  • [Avatar for David Sutherland]
    David Sutherland
    August 8, 2020 06:53 am

    “It merely says that copyright for the expression doesn’t extend to the ideas, methods of operation, procedures, and processes that may be embodied in the protected expression. Those are the purview of patent law.”

    Can I legally build a machine that runs my own creative, copyrighted Java code? If not, how does Oracle’s copyright suddenly extend to functionality and methods of operation of a machine that they don’t own?

    If I *can* build such a machine, why can’t Google?

  • [Avatar for Raymond Van Dyke]
    Raymond Van Dyke
    August 7, 2020 11:52 am

    Anon: With coders (I was one), code is thought of as something that should be free. “Let code be free” is a mantra. Also if “open source” that means free also. I can understand the confusion. Here, the APIs constituted thousands of lines of code, and instead of simply taking a license (as everybody else did), Google just took it verbatim and are now trying to “jimmy” the law to fit the bad facts.

  • [Avatar for Bob]
    August 7, 2020 11:34 am

    I am a Java programmer for 20 years, I feel like Oracle in this suit, treats me like trash.

    1) Programmers learned Java language in their own time and cost, Oracle did not pay or it
    2) Java language was hyped by Sun as a free language, even today, its advertised as open and free
    3) Oracle cheated by hiding patents and copyrights in free and open lanaguage
    4) Oracle put copyrights in code that belonged to “java.*” and “java.lang.*” files. Without “java.*” packages, the language was useless. Copyrighted materials were supposed to be only in “sun.*” packages.

    In this suit, Oracle is claiming copyright to a language, that millions of programmers invested their time and money. Its almost like someone claiming copyright to parts of English language. Totally unfair to Java programmers. Oracle and Google may settle or not, Google moves to Kotlyn, Go or something else, I remain as pure trash. Thanks to all.

  • [Avatar for Anon]
    August 6, 2020 07:58 pm

    I have to wonder what “balance” means to Ryan.

  • [Avatar for Jam]
    August 6, 2020 03:17 pm


    Sequence of relevant events for Google’s ‘don’t be evil’:
    1 Google writes “don’t be evil” into its code of conduct.
    2 An engineer successfully shoots down an advertising product arguing that the product is evil.
    3 Google removes “don’t be evil” from its code of conduct


  • [Avatar for Raymond Van Dyke]
    Raymond Van Dyke
    August 6, 2020 03:12 pm

    Oracle licensed the JAVA code to anyone, which was sensible so as to maintain the standard instead of allowing a myriad versions lose on the world. Reasonable terms also – so as to promote the standard. Open source can have terms for use, and does not mean openly infringing is ok. Fair use cannot be extended, such as proposed, to allow copying any tech/APIs out there. As for the analogy, copying the APIs is equivalent to copying the front page of a book, this is false. Perhaps copying and using various key passages throughout the book, without authorization and definitely for money, is a better analogy – which the Supreme Court has said is wrong. See Harper Row case.

  • [Avatar for Steve]
    August 6, 2020 02:43 pm

    Thanks for reading, Ryan. It seems you’re operating on some misconceptions. Oracle offers its code on a variety of terms depending on the usage, but it is undisputed in this case that Google did not operate within the terms of any license for the code they copied from Oracle. Don’t you think they’d have mentioned that sometime before this case got to the Supreme Court?

    Whatever else Google didn’t copy does not excuse what they DID copy. And I strongly disagree that fair use excuses the infringement. Perhaps if I’m able I’ll write on that separately.

    And my thoughts about allegations of Oracle copying in another context? My thoughts are that it has absolutely no bearing on Google’s liability in THIS case.

  • [Avatar for Ryan]
    August 6, 2020 11:25 am

    Wonder why it’s hard to find balanced commentary on this. Java has been open sourced since 2006 and I think it’s disingenuous to call copying the cover of a book a cheat code when everything inside is original. Google’s use is covered under fair use even if they did not go about it in the best manner. it would be detrimental to the whole industry to not allow apis to be covered under fair use. I would be interested in your thoughts of Oracle copying SQL from IBM.

  • [Avatar for Raymond Van Dyke]
    Raymond Van Dyke
    August 6, 2020 10:25 am

    Nice synopsis of the issues. For years, big tech has been chipping away at patent rights, even saying for software inventions that you have copyright to fall back on. Now, the argument is the reverse, and Copyright is not even safe under the twisted logic in this case. The outrageous fact scenario here compels a judgment against Google. As a former coder, all Google had to do is take a hundred, a thousand?, of its own coders, set up a clean room, and reverse engineer the parts of JAVA they needed. Instead, they just took the code, and stuck their middle finger in the face of Oracle and copyright law. I pray our Justices have the sense (9-0) to do justice here. Google’s tech is great, but this business decision to me violates Google’s credo: do no evil.

  • [Avatar for Bob Taylor]
    Bob Taylor
    August 6, 2020 09:49 am

    Steven, thank you for the outstanding analysis. It is spot on and clearly stated, no small trick with this subject matter. One can hope that your article makes its way to the Court and that at least some of the justices are paying attention to the economic consequences of the decisions that they make on IP matters.

  • [Avatar for Tim]
    August 6, 2020 09:43 am

    I’m sure that before this is over, GOOGLE will be calling them “patent trolls”, just like they did to Vringo, (Vringo vs IP Internet). Even after Vringo beat them in court with a 12-0 jury win on every count, Google was able to get 2 of 3 judges in the Appeals Court to toss out the case. And for some reason, when it went to the Supreme Court, it would not even be looked at? I wonder where Mayer and Wallach spend their free time? Probably on Google Island.

  • [Avatar for Jason Newport]
    Jason Newport
    August 6, 2020 07:09 am

    Netlist just won a 10 yr battle with Google waiting to see the results $$$ NLST