├── image1.gif ├── rule-110-row-1-opt-2.png ├── rule-110-row-1-opt-3.png ├── rule-110-row-2-opt-2.png ├── rule-110-row-2-opt-3.png ├── rule-110-row-3-opt-2.png ├── rule-110-row-3-opt-3.png ├── rule-110-row-4-opt-3.png ├── rule-110-row-5-opt-3.png ├── rule-110-row-6-opt-3.png ├── rule-110-row-7-opt-3.png ├── rule-110-row-8-opt-3.png ├── rule-110-row-9-opt-3.png ├── rule-110-row-10-opt-3.png ├── rule-110-youtube-thumbnail.png ├── LICENSE └── README.md /image1.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/image1.gif -------------------------------------------------------------------------------- /rule-110-row-1-opt-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-1-opt-2.png -------------------------------------------------------------------------------- /rule-110-row-1-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-1-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-2-opt-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-2-opt-2.png -------------------------------------------------------------------------------- /rule-110-row-2-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-2-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-3-opt-2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-3-opt-2.png -------------------------------------------------------------------------------- /rule-110-row-3-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-3-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-4-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-4-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-5-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-5-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-6-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-6-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-7-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-7-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-8-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-8-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-9-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-9-opt-3.png -------------------------------------------------------------------------------- /rule-110-row-10-opt-3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-row-10-opt-3.png -------------------------------------------------------------------------------- /rule-110-youtube-thumbnail.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/supertestnet/rule-110-in-bitcoin-script/HEAD/rule-110-youtube-thumbnail.png -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Creative Commons Legal Code 2 | 3 | CC0 1.0 Universal 4 | 5 | CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE 6 | LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN 7 | ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS 8 | INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES 9 | REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS 10 | PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM 11 | THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED 12 | HEREUNDER. 13 | 14 | Statement of Purpose 15 | 16 | The laws of most jurisdictions throughout the world automatically confer 17 | exclusive Copyright and Related Rights (defined below) upon the creator 18 | and subsequent owner(s) (each and all, an "owner") of an original work of 19 | authorship and/or a database (each, a "Work"). 20 | 21 | Certain owners wish to permanently relinquish those rights to a Work for 22 | the purpose of contributing to a commons of creative, cultural and 23 | scientific works ("Commons") that the public can reliably and without fear 24 | of later claims of infringement build upon, modify, incorporate in other 25 | works, reuse and redistribute as freely as possible in any form whatsoever 26 | and for any purposes, including without limitation commercial purposes. 27 | These owners may contribute to the Commons to promote the ideal of a free 28 | culture and the further production of creative, cultural and scientific 29 | works, or to gain reputation or greater distribution for their Work in 30 | part through the use and efforts of others. 31 | 32 | For these and/or other purposes and motivations, and without any 33 | expectation of additional consideration or compensation, the person 34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she 35 | is an owner of Copyright and Related Rights in the Work, voluntarily 36 | elects to apply CC0 to the Work and publicly distribute the Work under its 37 | terms, with knowledge of his or her Copyright and Related Rights in the 38 | Work and the meaning and intended legal effect of CC0 on those rights. 39 | 40 | 1. Copyright and Related Rights. A Work made available under CC0 may be 41 | protected by copyright and related or neighboring rights ("Copyright and 42 | Related Rights"). Copyright and Related Rights include, but are not 43 | limited to, the following: 44 | 45 | i. the right to reproduce, adapt, distribute, perform, display, 46 | communicate, and translate a Work; 47 | ii. moral rights retained by the original author(s) and/or performer(s); 48 | iii. publicity and privacy rights pertaining to a person's image or 49 | likeness depicted in a Work; 50 | iv. rights protecting against unfair competition in regards to a Work, 51 | subject to the limitations in paragraph 4(a), below; 52 | v. rights protecting the extraction, dissemination, use and reuse of data 53 | in a Work; 54 | vi. database rights (such as those arising under Directive 96/9/EC of the 55 | European Parliament and of the Council of 11 March 1996 on the legal 56 | protection of databases, and under any national implementation 57 | thereof, including any amended or successor version of such 58 | directive); and 59 | vii. other similar, equivalent or corresponding rights throughout the 60 | world based on applicable law or treaty, and any national 61 | implementations thereof. 62 | 63 | 2. Waiver. To the greatest extent permitted by, but not in contravention 64 | of, applicable law, Affirmer hereby overtly, fully, permanently, 65 | irrevocably and unconditionally waives, abandons, and surrenders all of 66 | Affirmer's Copyright and Related Rights and associated claims and causes 67 | of action, whether now known or unknown (including existing as well as 68 | future claims and causes of action), in the Work (i) in all territories 69 | worldwide, (ii) for the maximum duration provided by applicable law or 70 | treaty (including future time extensions), (iii) in any current or future 71 | medium and for any number of copies, and (iv) for any purpose whatsoever, 72 | including without limitation commercial, advertising or promotional 73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each 74 | member of the public at large and to the detriment of Affirmer's heirs and 75 | successors, fully intending that such Waiver shall not be subject to 76 | revocation, rescission, cancellation, termination, or any other legal or 77 | equitable action to disrupt the quiet enjoyment of the Work by the public 78 | as contemplated by Affirmer's express Statement of Purpose. 79 | 80 | 3. Public License Fallback. Should any part of the Waiver for any reason 81 | be judged legally invalid or ineffective under applicable law, then the 82 | Waiver shall be preserved to the maximum extent permitted taking into 83 | account Affirmer's express Statement of Purpose. In addition, to the 84 | extent the Waiver is so judged Affirmer hereby grants to each affected 85 | person a royalty-free, non transferable, non sublicensable, non exclusive, 86 | irrevocable and unconditional license to exercise Affirmer's Copyright and 87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the 88 | maximum duration provided by applicable law or treaty (including future 89 | time extensions), (iii) in any current or future medium and for any number 90 | of copies, and (iv) for any purpose whatsoever, including without 91 | limitation commercial, advertising or promotional purposes (the 92 | "License"). The License shall be deemed effective as of the date CC0 was 93 | applied by Affirmer to the Work. Should any part of the License for any 94 | reason be judged legally invalid or ineffective under applicable law, such 95 | partial invalidity or ineffectiveness shall not invalidate the remainder 96 | of the License, and in such case Affirmer hereby affirms that he or she 97 | will not (i) exercise any of his or her remaining Copyright and Related 98 | Rights in the Work or (ii) assert any associated claims and causes of 99 | action with respect to the Work, in either case contrary to Affirmer's 100 | express Statement of Purpose. 101 | 102 | 4. Limitations and Disclaimers. 103 | 104 | a. No trademark or patent rights held by Affirmer are waived, abandoned, 105 | surrendered, licensed or otherwise affected by this document. 106 | b. Affirmer offers the Work as-is and makes no representations or 107 | warranties of any kind concerning the Work, express, implied, 108 | statutory or otherwise, including without limitation warranties of 109 | title, merchantability, fitness for a particular purpose, non 110 | infringement, or the absence of latent or other defects, accuracy, or 111 | the present or absence of errors, whether or not discoverable, all to 112 | the greatest extent permissible under applicable law. 113 | c. Affirmer disclaims responsibility for clearing rights of other persons 114 | that may apply to the Work or any use thereof, including without 115 | limitation any person's Copyright and Related Rights in the Work. 116 | Further, Affirmer disclaims responsibility for obtaining any necessary 117 | consents, permissions or other rights required for any use of the 118 | Work. 119 | d. Affirmer understands and acknowledges that Creative Commons is not a 120 | party to this document and has no duty or obligation with respect to 121 | this CC0 or use of the Work. 122 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Rule 110 in Bitcoin Script 2 | 3 | # Video explanation 4 | 5 | [![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-youtube-thumbnail.png)](https://www.youtube.com/watch?v=jZmjSZdYqpI) 6 | 7 | # On the (testnet) blockchain 8 | 9 | The following transaction spent coins from an address where the act of checking that the spend was valid required all bitcoin nodes to execute two generations of a [Rule 110 Cellular Automaton](https://en.wikipedia.org/wiki/Rule_110) after being given the first generation as input: https://blockstream.info/testnet/tx/3dbdc2142f5e006a0bcd186abbb85a5f6612c8c25666ee039776ce3e970df1c7?expand 10 | 11 | Here is the raw transaction hex: `020000000001015ebd88469de17bce4e9da9d330562f4a6792a2a13caa8a5018bb3f0038cb68e40000000000feffffff01bc02000000000000160014ff9da567e62f30ea8654fa1d5fbd47bef8e3be13050000000101e1006f7c639a916b51676b686d74518763007c6874528763007b7b686f7c639a916b51676b686d74518763007c6874528763007b7b686f7c639a916b51676b686d74518763007c6874528763007b7b686f7c639a916b51676b686d74518763007c6874528763007b7b686d756c6c6c6c006f7c639a916b51676b686d74518763007c6874528763007b7b686f7c639a916b51676b686d74518763007c6874528763007b7b686f7c639a916b51676b686d74518763007c6874528763007b7b686f7c639a916b51676b686d74518763007c6874528763007b7b686d756c6c6c6c6d6d5100000000` 12 | 13 | # What is Rule 110? 14 | 15 | Rule 110 is a name for a group of black and white patterns. A common one appears in this picture: 16 | 17 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/image1.gif) 18 | 19 | It is an object of study by computer scientists because if you modify the top line of the image, the pattern it produces changes in predictable ways, and you can use this predictable behavior to write programs that allow people to supply any sequence of black squares and white squares as input and get an output on some lower line of the image. If users supply real information to a Rule 110 program, the Rule 110 program can manipulate that information however the programmer wants it to, and you can always tell the users that they will find the result of the computation on some pre-agreed line lower down in the image. There is more information in the wiki: https://en.wikipedia.org/wiki/Rule_110 20 | 21 | What I think is cool is that the rules for creating a Rule 110 machine can be written in Bitcoin Script and executed by bitcoin nodes. 22 | 23 | # Does this mean bitcoin's programming language, Bitcoin Script, is turing complete? 24 | 25 | I think so, but I am not an expert on these things and I am probably missing something. Last year a guy did a similar thing on the Bitcoin SV network and there was [an interesting thread on Hacker News](https://news.ycombinator.com/item?id=28574546) about it. In that thread, someone smarter than me thinks it doesn't count as turing complete for several reasons. One of them (the lack of loops) is dealt with below, another one is that you have to prepare these addresses with lots of parameters that are usually not known in *normal* turing machines. For example, I knew that my program would process 4 bits of data so I manually instructed it to halt after processing those four bits. A *normal* turing machine could process varying numbers of bits, even billions of bits. There would be some code inside the program that checks if there is any more input and that checker function would automatically tell the program to halt when there is none. But my implementation lacks that feature so maybe it's still not a real turing machine. 26 | 27 | On the other hand, I think I could probably implement an input length checker like that very easily, and I don't think such a checker is really necessary for a machine to count as turing complete. All real-world turing machines have limited resources, such as memory, and therefore they cannot process an unlimited number of bits. If they try to process a program that consumes more resources than they have available, their checker will never fire and the turing machine will just break after it runs out of memory or a source of energy or after its mechanical parts wear out. Bitcoin's security measures help prevent breakage by *severely* limiting the number of operations you can do, as well as how much data you can process, but since *all* real world turing machines have limits too (just much larger ones) I think it's fair to call my Rule 110 simulator a universal turing machine, even without something that checks the length of the user's input and automatically tells it to halt when all the data is processed. 28 | 29 | # What about loops? I thought you needed loops to be turing complete, and bitcoin does not have loops 30 | 31 | I don't think you need them. A turing machine needs to move between different states of operation where it does different things depending on the user's input, but it's okay if those states are laid out sequentially. Then the machine just progresses from e.g. state 0 to state 1 to state 2 and those states all tell it what to do depending on what the user's input is. A machine that operates in this way never needs to "loop back" to a prior state. So you don't actually need loops to simulate a turing machine -- or at least I don't think you do, but maybe I'm missing something. 32 | 33 | I will note that a lot of people who are much smarter than me think loops are basically the defining feature that sets a Turing machine apart from every other type of virtual machine. For example, Russell O'Connor said: "every [Turing-complete] programming language must have infinite loops while Bitcoin Script has no looping behavior at all." [source](https://www.reddit.com/r/btc/comments/6hjxiy/new_craig_wright_interview_part_2_on/diz9g69/) He also said: "Unbounded search is literally the defining feature that sets apart Turing complete languages from Turing incomplete languages." [source](https://np.reddit.com/r/Bitcoin/comments/4pdx6k/comparison_between_bitcoin_and_ethereums/d4lerhw/) 34 | 35 | I don't agree with him but that probably just means I am wrong. I think loops are simulatable by taking the function you want to loop and, instead of doing a loop, copy-paste that function a billion times in a row, while having each of these billion functions pass its output to the next function as input. Obviously that's not actually "unbounded" or "infinite," but I don't think any Turing machine actually has unbounded or infinite capabilities either, because all of them are made in the real world where resources are not infinite. My set of a billion sequential functions and your unbounded loop language will both compute all functions except the ones that require so much processing, the processor falls apart before it finishes processing the data. Therefore I say loops can be effectively simulated by copy-pasting an identical function many times. But in a contest between me and Russel O'Connor, you should listen to him, not me. So there's that. 36 | 37 | # If Rule 110 is turing complete, is it useful to simulate it in Bitcoin Script? 38 | 39 | I'm really not sure but quite possibly not. Bitcoin's limitations on script length include a rule that no more than 200 operations can be performed in a given script (with an exception for operations that only deposit a number onto the stack). A Rule 110 program that actually did anything signficant would probably need to perform hundreds of thousands of operations on the user's input, and the user's input would also need to be absolutely massive. So this is really just a toy simulator, not something you can realistically do meaningful processing with. But I don't need it to be useful. I had a lot of fun making it and to me the fun is worth the effort. 40 | 41 | On the other hand, if I'm right that Bitcoin Script is turing complete, there are some very useful things you can do without simulating Rule 110, which is incredibly inefficient as a computing device anyway. The very existence of my "Proof of Turing Completeness" (if my proof is valid, which it might not be) may prompt some people to seek out some of the other unexpected things Bitcoin Script can do. It's certainly got me on the watch for fantastic discoveries. The cellular automaton I simulated creates an environment on the boundary between chaos and stability. To me that sounds like a pretty neat place to explore. 42 | 43 | # How does it work? 44 | 45 | The heart of the program is this function, which takes any sequence of 3 binary digits as input and computes an output that corresponds to what it should be on a Rule 110 table, which it then outputs to the altstack: 46 | 47 | ``` 48 | OP_SWAP 49 | OP_IF 50 | OP_BOOLAND 51 | OP_NOT 52 | OP_TOALTSTACK 53 | OP_1 54 | OP_ELSE 55 | OP_TOALTSTACK 56 | OP_ENDIF 57 | ``` 58 | 59 | I originally implemented a Rule 110 output function that was much larger, it had 55 operations instead of 9. It caused problems because I couldn't run the function very many times without consuming the 200 operations I am allowed to use according to bitcoin's consensus rules. But then Dusty Daemon took a look at my code and suggested using boolean logic to compress the function. I googled to see if anyone had a compressed way of computing Rule 110 outputs using boolean logic and I found this research paper: https://peerj.com/preprints/2553.pdf The author proves that Rule 110's output can be computed using this pseudocode: 60 | 61 | ``` 62 | If c == true: 63 | print(p NAND q) 64 | Else: 65 | print(q) 66 | End if 67 | ``` 68 | 69 | Which is what I implemented in Bitcoin Script above. (The extra <1> I outputed in my version is necessary so that the program always leaves 1 element on the stack, which is required by other parts of my overall program.) I am really glad that someone figured out what is probably the most efficient possible way to compute Rule 110 outputs -- standing on the shoulders of giants is the only way my program works at all. 70 | 71 | # A few prefixes and suffixes 72 | 73 | To compute a full line of Rule 110 the program can't just run the Rule 110 output function on 3 digits. It needs to take a string of varying length as input and run many times to compute a full line. To do this my program adds to the main function a few prefixes and suffixes. It also needs room to run a bunch of times – as many times as the inputs you provide. E.g. if the programmer wants users to provide a sequence of 10 0s and 1s as input, he or she will need to copy/paste the Rule 110 output function 10 times. He or she will also need to apply the following prefix before each run of the function: `OP_3DUP` (My rule 110 function consumes the top 2 digits of input but the bottom 2 need to be used again the next time it runs, so I duplicate all 3 and then drop 2 inputs later after the program runs.) 74 | 75 | The program also needs the programmer to apply the following suffix after each run of the function: 76 | 77 | ``` 78 | OP_2DROP 79 | OP_DEPTH 80 | OP_1 81 | OP_EQUAL 82 | OP_IF 83 | OP_0 84 | OP_SWAP 85 | OP_ENDIF 86 | OP_DEPTH 87 | OP_2 88 | OP_EQUAL 89 | OP_IF 90 | OP_0 91 | OP_ROT 92 | OP_ROT 93 | OP_ENDIF 94 | ``` 95 | 96 | This sequence of commands cleans up the stack and loads the next set of 3 inputs so that they can be processed by the Rule 110 output function. If we are nearing the end of the stack it also adds up to two 0s to the bottom of the stack so that the OP_3DUP function won't fail when the stack runs out of elements. This is fine because Rule 110 assumes that if you are computing the output of only 2 digits, there is an imagined third one that is always a 0. 97 | 98 | When all of these prefixes and suffixes are applied I get this result which I repeat for however many inputs there are to the program: 99 | 100 | ``` 101 | OP_3DUP 102 | OP_SWAP 103 | OP_IF 104 | OP_BOOLAND 105 | OP_NOT 106 | OP_TOALTSTACK 107 | OP_1 108 | OP_ELSE 109 | OP_TOALTSTACK 110 | OP_ENDIF 111 | OP_2DROP 112 | OP_DEPTH 113 | OP_1 114 | OP_EQUAL 115 | OP_IF 116 | OP_0 117 | OP_SWAP 118 | OP_ENDIF 119 | OP_DEPTH 120 | OP_2 121 | OP_EQUAL 122 | OP_IF 123 | OP_0 124 | OP_ROT 125 | OP_ROT 126 | OP_ENDIF 127 | ``` 128 | 129 | You can see that this sequence of opcodes and numbers repeats 4 times in the top half of the witness script that I actually ran on the blockchain: 130 | 131 | ``` 132 | OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF 133 | ``` 134 | 135 | # A few more prefixes and suffixes 136 | 137 | By repeating the Rule 110 output function 4 times, Bitcoin Script can take any line of any 4 digit Rule 110 pattern as input and compute the next line as output. But it's not ready yet, it needs a few more prefixes and suffixes and there is space to compute 2 lines so let's do that. 138 | 139 | Earlier I said that if you are computing the output of only 2 digits using Rule 110, there is an imagined third digit that is always a 0. That's not only true when you are nearing the end of the input elements, it's also true at the beginning. Another way of saying that is this: to compute the "rightmost" digit of each line of the Rule 110 pattern, assume there is a 0 after whatever digits you supplied as input. So my function needs to deposit a zero onto the top of the stack right off the bat, which is why the first instruction in my witness script is `OP_0`. That prefix needs to be applied before you compute any line of Rule 110 so we will end up putting it on the stack twice, once at the beginning of the witness script and once in the middle. 140 | 141 | Also, when you compute the second line of Rule 110 from the first (remember, the first line is supplied as input), the outputs are all deposited to the altstack. To use them as input for the third line of Rule 110, we need to retrieve them from the altstack. But before doing that, we need to "tidy up" the stack, because the suffix to the Rule 110 output function always adds up to two 0s to the stack when we are nearing the end of the stack, and once the line is complete we don't need those 0s anymore. So let's tidy up the stack by dropping the last two 0s and then retrieve Line 2 (which is currently on the altstack) as input for Line 3. 142 | 143 | ``` 144 | OP_2DROP 145 | OP_DROP 146 | OP_FROMALTSTACK 147 | OP_FROMALTSTACK 148 | OP_FROMALTSTACK 149 | OP_FROMALTSTACK 150 | ``` 151 | 152 | # The whole program 153 | 154 | If you had 10 bytes of input and if you consequently ran the Rule 110 output function 10 times, you'd need to retrieve 10 items from the altstack, but here I am only retrieving 4 items because I assume there are only 4 bytes of input. But we're almost done! By retrieving the bytes from the altstack we are back in our starting position except with a new input line, so we can duplicate what we did before to get the third line of Rule 110. The whole program looks like this: 155 | 156 | ``` 157 | OP_0 OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_2DROP OP_DROP OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK OP_0 OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_3DUP OP_SWAP OP_IF OP_BOOLAND OP_NOT OP_TOALTSTACK OP_PUSHNUM_1 OP_ELSE OP_TOALTSTACK OP_ENDIF OP_2DROP OP_DEPTH OP_PUSHNUM_1 OP_EQUAL OP_IF OP_0 OP_SWAP OP_ENDIF OP_DEPTH OP_PUSHNUM_2 OP_EQUAL OP_IF OP_0 OP_ROT OP_ROT OP_ENDIF OP_2DROP OP_DROP OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK OP_FROMALTSTACK OP_2DROP OP_2DROP OP_PUSHNUM_1 158 | ``` 159 | 160 | You'll notice that at the end I do op_2drop twice and I push a 1 to the stack. I drop everything because Bitcoin nodes don't like you to have anything on the stack at the end of your function except a single item that is something other than OP_FALSE or OP_0. So I drop whatever I retrieved from the altstack and push a number 1 so that the program always succeeds as long as you provide 4 binary digits of initial input. Once it succeeds you can spend any money in the address to wherever you want. But in the process you got Bitcoin nodes to execute 2 generations of a cellular automaton and you simulated a universal turing machine, so I'd say that's a job well done. 161 | 162 | # Block explorers, IDEs, and Screenshots 163 | 164 | Be aware that block explorers usually choose not to display what’s on the stack after each operation of the witness script. (I’m not aware of any block explorer that DOES show play-by-play results of script operations.) The outcomes of these operations are also not stored on the blockchain. So how do you use them? Well, several things ARE stored on the blockchain, including the inputs to the program, the program's logic, the fact that the program executed successfully, and that money moved according to the rules of the outcome. My implementation of Rule 110 allows the user who supplies the inputs to spend the money however he wants, regardless of what the results are, but you can also add conditions to enforce rules like "only let the user withdraw the money if they supply certain inputs" or "let one of several users withdraw the money depending on the results of the program and the inputs supplied by the users." 165 | 166 | Also, since you know the inputs to the program and the program itself, you can calculate each step of the program to view the results. Maybe someday block explorers will also display the results of each step of programs like this one so that you can view the results on block explorers. (I think ethereum block explorers do that.) 167 | 168 | Since block explorers don’t currently show the results of script operations, the best option to view the results right now is probably to run the scripts yourself. I use a Bitcoin Script IDE for this. IDE means integrated development environment, it's a tool for programmers. Basically I open up the IDE and copy in the full script, then it shows me the results of each operation in a side pane. The one I use is [Script Wiz](https://ide.scriptwiz.app/), which is primarily for developing Liquid blockchain apps, but also supports Bitcoin Script. Here are some screenshots of what it looks like to run my program in the Script Wiz IDE: 169 | 170 | Row 1 of Rule 110 is supplied as input to the program on line 4: 171 | 172 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-1-opt-2.png) 173 | 174 | Row 2 of Rule 110 gets computed from row 1 on line 111: 175 | 176 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-2-opt-2.png) 177 | 178 | Row 3 of Rule 110 gets computed from row 2 on line 222: 179 | 180 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-2-opt-2.png) 181 | 182 | As a reminder, here is what the first 10 lines of Rule 110 look like when 9 0s and a 1 are supplied as input: 183 | 184 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/image1.gif) 185 | 186 | Here are the lines my program computes (except it doesn’t compute the first one because it is given as input): 187 | 188 | ``` 189 | [row 1] 0 0 0 1 190 | [row 2] 0 0 1 1 191 | [row 3] 0 1 1 1 192 | ``` 193 | 194 | I know that the first three rows of Rule 110 aren’t very interesting, because they are just a stack of 1s that progressively takes up more and more of the row. The pattern gets more complex if you let the program continue, but even the fact that you can compute the first three lines using the logic of Rule 110 demonstrates that bitcoin can simulate a Rule 110 program. The program is not “just stacking 1s” here, it’s doing actual computation according to the logic of Rule 110, and the first three rows of that just happen to be a stack of 1s that gets bigger at first before turning into a more complex pattern. A programmer can compute any desired pattern by supplying the right inputs. 195 | 196 | In fact, I have a longer version of the script that computes the first 10 lines of Rule 110. This one uses more operations than bitcoin’s consensus rules allow in a transaction, so it can’t run on bitcoin unless maybe there’s a way to break it up into multiple transactions. It does run in the IDE I use and I provide it here to illustrate what happens if you can get the program to run longer on the blockchain. (Here I supply 9 0s and a 1 as input. Remember that a programmer can supply anything as input and if the programmer is clever enough they can use the predictability of Rule 110 to program a computable result. Rule 110 manipulates the information supplied to it in ways that allow a programmer to output whatever result they want on a predictable line, and by doing this they can simulate any computer program.) 197 | 198 | Row 1 is supplied as input on line 10: 199 | 200 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-1-opt-3.png) 201 | 202 | Row 2 of Rule 110 gets computed from row 1 on line 273: 203 | 204 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-2-opt-3.png) 205 | 206 | Row 3 of Rule 110 gets computed from row 1 on line 546: 207 | 208 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-3-opt-3.png) 209 | 210 | Row 4 of Rule 110 gets computed from row 1 on line 819: 211 | 212 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-4-opt-3.png) 213 | 214 | Row 5 of Rule 110 gets computed from row 1 on line 1092: 215 | 216 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-5-opt-3.png) 217 | 218 | Row 6 of Rule 110 gets computed from row 1 on line 1365: 219 | 220 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-6-opt-3.png) 221 | 222 | Row 7 of Rule 110 gets computed from row 1 on line 1638: 223 | 224 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-7-opt-3.png) 225 | 226 | Row 8 of Rule 110 gets computed from row 1 on line 1911: 227 | 228 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-8-opt-3.png) 229 | 230 | Row 9 of Rule 110 gets computed from row 1 on line 2184: 231 | 232 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-9-opt-3.png) 233 | 234 | Row 10 of Rule 110 gets computed from row 1 on line 2457: 235 | 236 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/rule-110-row-10-opt-3.png) 237 | 238 | As a reminder, here is what the first 10 lines of Rule 110 look like when 9 0s and a 1 are supplied as input: 239 | 240 | ![](https://supertestnet.github.io/rule-110-in-bitcoin-script/image1.gif) 241 | 242 | Here are the lines my bitcoin script computes (except it doesn’t compute the first one because it is given as input): 243 | 244 | ``` 245 | [row 1] 0 0 0 0 0 0 0 0 0 1 246 | [row 2] 0 0 0 0 0 0 0 0 1 1 247 | [row 3] 0 0 0 0 0 0 0 1 1 1 248 | [row 4] 0 0 0 0 0 0 1 1 0 1 249 | [row 5] 0 0 0 0 0 1 1 1 1 1 250 | [row 6] 0 0 0 0 1 1 0 0 0 1 251 | [row 7] 0 0 0 1 1 1 0 0 1 1 252 | [row 8] 0 0 1 1 0 1 0 1 1 1 253 | [row 9] 0 1 1 1 1 1 1 1 0 1 254 | [row 10] 1 1 0 0 0 0 0 1 1 1 255 | ``` 256 | # More code for playing with in the IDE 257 | 258 | The following script computes the first 3 lines of Rule 110 when given a line of 3 <0>s and one <1> as input. It is what I ended up running directly on the blockchain in [this transaction](https://blockstream.info/testnet/tx/3dbdc2142f5e006a0bcd186abbb85a5f6612c8c25666ee039776ce3e970df1c7?expand) (except I had to remove the comments). 259 | 260 | Put these first 5 lines in the "Stack Elements" pane of this IDE: https://ide.scriptwiz.app/ 261 | 262 | ``` 263 | //The following items are inputs. The output of my program should be various lines of rule 110. 264 | <0> 265 | <0> 266 | <0> 267 | <1> 268 | ``` 269 | 270 | Put all of these lines in the “Witness Script” pane. The results should show up on the righthand side of the screen. 271 | 272 | ``` 273 | //Start generation 2 274 | OP_0 275 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 276 | OP_3DUP 277 | OP_SWAP 278 | OP_IF 279 | OP_BOOLAND 280 | OP_NOT 281 | OP_TOALTSTACK 282 | OP_1 283 | OP_ELSE 284 | OP_TOALTSTACK 285 | OP_ENDIF 286 | //shift the tape to the right 287 | OP_2DROP 288 | //if we are nearing the end of the tape, add imaginary 0s to it 289 | OP_DEPTH 290 | OP_1 291 | OP_EQUAL 292 | OP_IF 293 | OP_0 294 | OP_SWAP 295 | OP_ENDIF 296 | OP_DEPTH 297 | OP_2 298 | OP_EQUAL 299 | OP_IF 300 | OP_0 301 | OP_ROT 302 | OP_ROT 303 | OP_ENDIF 304 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 305 | OP_3DUP 306 | OP_SWAP 307 | OP_IF 308 | OP_BOOLAND 309 | OP_NOT 310 | OP_TOALTSTACK 311 | OP_1 312 | OP_ELSE 313 | OP_TOALTSTACK 314 | OP_ENDIF 315 | //shift the tape to the right 316 | OP_2DROP 317 | //if we are nearing the end of the tape, add imaginary 0s to it 318 | OP_DEPTH 319 | OP_1 320 | OP_EQUAL 321 | OP_IF 322 | OP_0 323 | OP_SWAP 324 | OP_ENDIF 325 | OP_DEPTH 326 | OP_2 327 | OP_EQUAL 328 | OP_IF 329 | OP_0 330 | OP_ROT 331 | OP_ROT 332 | OP_ENDIF 333 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 334 | OP_3DUP 335 | OP_SWAP 336 | OP_IF 337 | OP_BOOLAND 338 | OP_NOT 339 | OP_TOALTSTACK 340 | OP_1 341 | OP_ELSE 342 | OP_TOALTSTACK 343 | OP_ENDIF 344 | //shift the tape to the right 345 | OP_2DROP 346 | //if we are nearing the end of the tape, add imaginary 0s to it 347 | OP_DEPTH 348 | OP_1 349 | OP_EQUAL 350 | OP_IF 351 | OP_0 352 | OP_SWAP 353 | OP_ENDIF 354 | OP_DEPTH 355 | OP_2 356 | OP_EQUAL 357 | OP_IF 358 | OP_0 359 | OP_ROT 360 | OP_ROT 361 | OP_ENDIF 362 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 363 | OP_3DUP 364 | OP_SWAP 365 | OP_IF 366 | OP_BOOLAND 367 | OP_NOT 368 | OP_TOALTSTACK 369 | OP_1 370 | OP_ELSE 371 | OP_TOALTSTACK 372 | OP_ENDIF 373 | //shift the tape to the right 374 | OP_2DROP 375 | //if we are nearing the end of the tape, add imaginary 0s to it 376 | OP_DEPTH 377 | OP_1 378 | OP_EQUAL 379 | OP_IF 380 | OP_0 381 | OP_SWAP 382 | OP_ENDIF 383 | OP_DEPTH 384 | OP_2 385 | OP_EQUAL 386 | OP_IF 387 | OP_0 388 | OP_ROT 389 | OP_ROT 390 | OP_ENDIF 391 | OP_2DROP 392 | OP_DROP 393 | OP_FROMALTSTACK 394 | OP_FROMALTSTACK 395 | OP_FROMALTSTACK 396 | OP_FROMALTSTACK 397 | //Start generation 3 398 | OP_0 399 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 400 | OP_3DUP 401 | OP_SWAP 402 | OP_IF 403 | OP_BOOLAND 404 | OP_NOT 405 | OP_TOALTSTACK 406 | OP_1 407 | OP_ELSE 408 | OP_TOALTSTACK 409 | OP_ENDIF 410 | //shift the tape to the right 411 | OP_2DROP 412 | //if we are nearing the end of the tape, add imaginary 0s to it 413 | OP_DEPTH 414 | OP_1 415 | OP_EQUAL 416 | OP_IF 417 | OP_0 418 | OP_SWAP 419 | OP_ENDIF 420 | OP_DEPTH 421 | OP_2 422 | OP_EQUAL 423 | OP_IF 424 | OP_0 425 | OP_ROT 426 | OP_ROT 427 | OP_ENDIF 428 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 429 | OP_3DUP 430 | OP_SWAP 431 | OP_IF 432 | OP_BOOLAND 433 | OP_NOT 434 | OP_TOALTSTACK 435 | OP_1 436 | OP_ELSE 437 | OP_TOALTSTACK 438 | OP_ENDIF 439 | //shift the tape to the right 440 | OP_2DROP 441 | //if we are nearing the end of the tape, add imaginary 0s to it 442 | OP_DEPTH 443 | OP_1 444 | OP_EQUAL 445 | OP_IF 446 | OP_0 447 | OP_SWAP 448 | OP_ENDIF 449 | OP_DEPTH 450 | OP_2 451 | OP_EQUAL 452 | OP_IF 453 | OP_0 454 | OP_ROT 455 | OP_ROT 456 | OP_ENDIF 457 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 458 | OP_3DUP 459 | OP_SWAP 460 | OP_IF 461 | OP_BOOLAND 462 | OP_NOT 463 | OP_TOALTSTACK 464 | OP_1 465 | OP_ELSE 466 | OP_TOALTSTACK 467 | OP_ENDIF 468 | //shift the tape to the right 469 | OP_2DROP 470 | //if we are nearing the end of the tape, add imaginary 0s to it 471 | OP_DEPTH 472 | OP_1 473 | OP_EQUAL 474 | OP_IF 475 | OP_0 476 | OP_SWAP 477 | OP_ENDIF 478 | OP_DEPTH 479 | OP_2 480 | OP_EQUAL 481 | OP_IF 482 | OP_0 483 | OP_ROT 484 | OP_ROT 485 | OP_ENDIF 486 | //Duplicate the top three stack elements so that they become inputs to the rule 110 function 487 | OP_3DUP 488 | OP_SWAP 489 | OP_IF 490 | OP_BOOLAND 491 | OP_NOT 492 | OP_TOALTSTACK 493 | OP_1 494 | OP_ELSE 495 | OP_TOALTSTACK 496 | OP_ENDIF 497 | //shift the tape to the right 498 | OP_2DROP 499 | //if we are nearing the end of the tape, add imaginary 0s to it 500 | OP_DEPTH 501 | OP_1 502 | OP_EQUAL 503 | OP_IF 504 | OP_0 505 | OP_SWAP 506 | OP_ENDIF 507 | OP_DEPTH 508 | OP_2 509 | OP_EQUAL 510 | OP_IF 511 | OP_0 512 | OP_ROT 513 | OP_ROT 514 | OP_ENDIF 515 | OP_2DROP 516 | OP_DROP 517 | OP_FROMALTSTACK 518 | OP_FROMALTSTACK 519 | OP_FROMALTSTACK 520 | OP_FROMALTSTACK 521 | ``` 522 | 523 | # Longer version 524 | 525 | What follows is a longer version of the script, without comments, that computes the first 10 lines of Rule 110. This longer version can't run on the real bitcoin network because it uses more operations than bitcoin's consensus rules permit in a single transaction. I include it here so you can experiment with it if you're into coding, and so you can see that the small version that actually runs on the bitcoin network is doing the same computations as the large one, just fewer of them. 526 | 527 | Put these first 11 lines in the "Stack Elements" pane of this IDE: https://ide.scriptwiz.app/ 528 | 529 | ``` 530 | //The following items are inputs. The output of my program should be various lines of rule 110. 531 | <0> 532 | <0> 533 | <0> 534 | <0> 535 | <0> 536 | <0> 537 | <0> 538 | <0> 539 | <0> 540 | <1> 541 | ``` 542 | 543 | Put all of these lines in the “Witness Script” pane. The results should show up on the righthand side of the screen. 544 | 545 | 546 | ``` 547 | OP_0 548 | OP_3DUP 549 | OP_SWAP 550 | OP_IF 551 | OP_BOOLAND 552 | OP_NOT 553 | OP_TOALTSTACK 554 | OP_1 555 | OP_ELSE 556 | OP_TOALTSTACK 557 | OP_ENDIF 558 | OP_2DROP 559 | OP_DEPTH 560 | OP_1 561 | OP_EQUAL 562 | OP_IF 563 | OP_0 564 | OP_SWAP 565 | OP_ENDIF 566 | OP_DEPTH 567 | OP_2 568 | OP_EQUAL 569 | OP_IF 570 | OP_0 571 | OP_ROT 572 | OP_ROT 573 | OP_ENDIF 574 | OP_3DUP 575 | OP_SWAP 576 | OP_IF 577 | OP_BOOLAND 578 | OP_NOT 579 | OP_TOALTSTACK 580 | OP_1 581 | OP_ELSE 582 | OP_TOALTSTACK 583 | OP_ENDIF 584 | OP_2DROP 585 | OP_DEPTH 586 | OP_1 587 | OP_EQUAL 588 | OP_IF 589 | OP_0 590 | OP_SWAP 591 | OP_ENDIF 592 | OP_DEPTH 593 | OP_2 594 | OP_EQUAL 595 | OP_IF 596 | OP_0 597 | OP_ROT 598 | OP_ROT 599 | OP_ENDIF 600 | OP_3DUP 601 | OP_SWAP 602 | OP_IF 603 | OP_BOOLAND 604 | OP_NOT 605 | OP_TOALTSTACK 606 | OP_1 607 | OP_ELSE 608 | OP_TOALTSTACK 609 | OP_ENDIF 610 | OP_2DROP 611 | OP_DEPTH 612 | OP_1 613 | OP_EQUAL 614 | OP_IF 615 | OP_0 616 | OP_SWAP 617 | OP_ENDIF 618 | OP_DEPTH 619 | OP_2 620 | OP_EQUAL 621 | OP_IF 622 | OP_0 623 | OP_ROT 624 | OP_ROT 625 | OP_ENDIF 626 | OP_3DUP 627 | OP_SWAP 628 | OP_IF 629 | OP_BOOLAND 630 | OP_NOT 631 | OP_TOALTSTACK 632 | OP_1 633 | OP_ELSE 634 | OP_TOALTSTACK 635 | OP_ENDIF 636 | OP_2DROP 637 | OP_DEPTH 638 | OP_1 639 | OP_EQUAL 640 | OP_IF 641 | OP_0 642 | OP_SWAP 643 | OP_ENDIF 644 | OP_DEPTH 645 | OP_2 646 | OP_EQUAL 647 | OP_IF 648 | OP_0 649 | OP_ROT 650 | OP_ROT 651 | OP_ENDIF 652 | OP_3DUP 653 | OP_SWAP 654 | OP_IF 655 | OP_BOOLAND 656 | OP_NOT 657 | OP_TOALTSTACK 658 | OP_1 659 | OP_ELSE 660 | OP_TOALTSTACK 661 | OP_ENDIF 662 | OP_2DROP 663 | OP_DEPTH 664 | OP_1 665 | OP_EQUAL 666 | OP_IF 667 | OP_0 668 | OP_SWAP 669 | OP_ENDIF 670 | OP_DEPTH 671 | OP_2 672 | OP_EQUAL 673 | OP_IF 674 | OP_0 675 | OP_ROT 676 | OP_ROT 677 | OP_ENDIF 678 | OP_3DUP 679 | OP_SWAP 680 | OP_IF 681 | OP_BOOLAND 682 | OP_NOT 683 | OP_TOALTSTACK 684 | OP_1 685 | OP_ELSE 686 | OP_TOALTSTACK 687 | OP_ENDIF 688 | OP_2DROP 689 | OP_DEPTH 690 | OP_1 691 | OP_EQUAL 692 | OP_IF 693 | OP_0 694 | OP_SWAP 695 | OP_ENDIF 696 | OP_DEPTH 697 | OP_2 698 | OP_EQUAL 699 | OP_IF 700 | OP_0 701 | OP_ROT 702 | OP_ROT 703 | OP_ENDIF 704 | OP_3DUP 705 | OP_SWAP 706 | OP_IF 707 | OP_BOOLAND 708 | OP_NOT 709 | OP_TOALTSTACK 710 | OP_1 711 | OP_ELSE 712 | OP_TOALTSTACK 713 | OP_ENDIF 714 | OP_2DROP 715 | OP_DEPTH 716 | OP_1 717 | OP_EQUAL 718 | OP_IF 719 | OP_0 720 | OP_SWAP 721 | OP_ENDIF 722 | OP_DEPTH 723 | OP_2 724 | OP_EQUAL 725 | OP_IF 726 | OP_0 727 | OP_ROT 728 | OP_ROT 729 | OP_ENDIF 730 | OP_3DUP 731 | OP_SWAP 732 | OP_IF 733 | OP_BOOLAND 734 | OP_NOT 735 | OP_TOALTSTACK 736 | OP_1 737 | OP_ELSE 738 | OP_TOALTSTACK 739 | OP_ENDIF 740 | OP_2DROP 741 | OP_DEPTH 742 | OP_1 743 | OP_EQUAL 744 | OP_IF 745 | OP_0 746 | OP_SWAP 747 | OP_ENDIF 748 | OP_DEPTH 749 | OP_2 750 | OP_EQUAL 751 | OP_IF 752 | OP_0 753 | OP_ROT 754 | OP_ROT 755 | OP_ENDIF 756 | OP_3DUP 757 | OP_SWAP 758 | OP_IF 759 | OP_BOOLAND 760 | OP_NOT 761 | OP_TOALTSTACK 762 | OP_1 763 | OP_ELSE 764 | OP_TOALTSTACK 765 | OP_ENDIF 766 | OP_2DROP 767 | OP_DEPTH 768 | OP_1 769 | OP_EQUAL 770 | OP_IF 771 | OP_0 772 | OP_SWAP 773 | OP_ENDIF 774 | OP_DEPTH 775 | OP_2 776 | OP_EQUAL 777 | OP_IF 778 | OP_0 779 | OP_ROT 780 | OP_ROT 781 | OP_ENDIF 782 | OP_3DUP 783 | OP_SWAP 784 | OP_IF 785 | OP_BOOLAND 786 | OP_NOT 787 | OP_TOALTSTACK 788 | OP_1 789 | OP_ELSE 790 | OP_TOALTSTACK 791 | OP_ENDIF 792 | OP_2DROP 793 | OP_DEPTH 794 | OP_1 795 | OP_EQUAL 796 | OP_IF 797 | OP_0 798 | OP_SWAP 799 | OP_ENDIF 800 | OP_DEPTH 801 | OP_2 802 | OP_EQUAL 803 | OP_IF 804 | OP_0 805 | OP_ROT 806 | OP_ROT 807 | OP_ENDIF 808 | OP_2DROP 809 | OP_DROP 810 | OP_FROMALTSTACK 811 | OP_FROMALTSTACK 812 | OP_FROMALTSTACK 813 | OP_FROMALTSTACK 814 | OP_FROMALTSTACK 815 | OP_FROMALTSTACK 816 | OP_FROMALTSTACK 817 | OP_FROMALTSTACK 818 | OP_FROMALTSTACK 819 | OP_FROMALTSTACK 820 | OP_0 821 | OP_3DUP 822 | OP_SWAP 823 | OP_IF 824 | OP_BOOLAND 825 | OP_NOT 826 | OP_TOALTSTACK 827 | OP_1 828 | OP_ELSE 829 | OP_TOALTSTACK 830 | OP_ENDIF 831 | OP_2DROP 832 | OP_DEPTH 833 | OP_1 834 | OP_EQUAL 835 | OP_IF 836 | OP_0 837 | OP_SWAP 838 | OP_ENDIF 839 | OP_DEPTH 840 | OP_2 841 | OP_EQUAL 842 | OP_IF 843 | OP_0 844 | OP_ROT 845 | OP_ROT 846 | OP_ENDIF 847 | OP_3DUP 848 | OP_SWAP 849 | OP_IF 850 | OP_BOOLAND 851 | OP_NOT 852 | OP_TOALTSTACK 853 | OP_1 854 | OP_ELSE 855 | OP_TOALTSTACK 856 | OP_ENDIF 857 | OP_2DROP 858 | OP_DEPTH 859 | OP_1 860 | OP_EQUAL 861 | OP_IF 862 | OP_0 863 | OP_SWAP 864 | OP_ENDIF 865 | OP_DEPTH 866 | OP_2 867 | OP_EQUAL 868 | OP_IF 869 | OP_0 870 | OP_ROT 871 | OP_ROT 872 | OP_ENDIF 873 | OP_3DUP 874 | OP_SWAP 875 | OP_IF 876 | OP_BOOLAND 877 | OP_NOT 878 | OP_TOALTSTACK 879 | OP_1 880 | OP_ELSE 881 | OP_TOALTSTACK 882 | OP_ENDIF 883 | OP_2DROP 884 | OP_DEPTH 885 | OP_1 886 | OP_EQUAL 887 | OP_IF 888 | OP_0 889 | OP_SWAP 890 | OP_ENDIF 891 | OP_DEPTH 892 | OP_2 893 | OP_EQUAL 894 | OP_IF 895 | OP_0 896 | OP_ROT 897 | OP_ROT 898 | OP_ENDIF 899 | OP_3DUP 900 | OP_SWAP 901 | OP_IF 902 | OP_BOOLAND 903 | OP_NOT 904 | OP_TOALTSTACK 905 | OP_1 906 | OP_ELSE 907 | OP_TOALTSTACK 908 | OP_ENDIF 909 | OP_2DROP 910 | OP_DEPTH 911 | OP_1 912 | OP_EQUAL 913 | OP_IF 914 | OP_0 915 | OP_SWAP 916 | OP_ENDIF 917 | OP_DEPTH 918 | OP_2 919 | OP_EQUAL 920 | OP_IF 921 | OP_0 922 | OP_ROT 923 | OP_ROT 924 | OP_ENDIF 925 | OP_3DUP 926 | OP_SWAP 927 | OP_IF 928 | OP_BOOLAND 929 | OP_NOT 930 | OP_TOALTSTACK 931 | OP_1 932 | OP_ELSE 933 | OP_TOALTSTACK 934 | OP_ENDIF 935 | OP_2DROP 936 | OP_DEPTH 937 | OP_1 938 | OP_EQUAL 939 | OP_IF 940 | OP_0 941 | OP_SWAP 942 | OP_ENDIF 943 | OP_DEPTH 944 | OP_2 945 | OP_EQUAL 946 | OP_IF 947 | OP_0 948 | OP_ROT 949 | OP_ROT 950 | OP_ENDIF 951 | OP_3DUP 952 | OP_SWAP 953 | OP_IF 954 | OP_BOOLAND 955 | OP_NOT 956 | OP_TOALTSTACK 957 | OP_1 958 | OP_ELSE 959 | OP_TOALTSTACK 960 | OP_ENDIF 961 | OP_2DROP 962 | OP_DEPTH 963 | OP_1 964 | OP_EQUAL 965 | OP_IF 966 | OP_0 967 | OP_SWAP 968 | OP_ENDIF 969 | OP_DEPTH 970 | OP_2 971 | OP_EQUAL 972 | OP_IF 973 | OP_0 974 | OP_ROT 975 | OP_ROT 976 | OP_ENDIF 977 | OP_3DUP 978 | OP_SWAP 979 | OP_IF 980 | OP_BOOLAND 981 | OP_NOT 982 | OP_TOALTSTACK 983 | OP_1 984 | OP_ELSE 985 | OP_TOALTSTACK 986 | OP_ENDIF 987 | OP_2DROP 988 | OP_DEPTH 989 | OP_1 990 | OP_EQUAL 991 | OP_IF 992 | OP_0 993 | OP_SWAP 994 | OP_ENDIF 995 | OP_DEPTH 996 | OP_2 997 | OP_EQUAL 998 | OP_IF 999 | OP_0 1000 | OP_ROT 1001 | OP_ROT 1002 | OP_ENDIF 1003 | OP_3DUP 1004 | OP_SWAP 1005 | OP_IF 1006 | OP_BOOLAND 1007 | OP_NOT 1008 | OP_TOALTSTACK 1009 | OP_1 1010 | OP_ELSE 1011 | OP_TOALTSTACK 1012 | OP_ENDIF 1013 | OP_2DROP 1014 | OP_DEPTH 1015 | OP_1 1016 | OP_EQUAL 1017 | OP_IF 1018 | OP_0 1019 | OP_SWAP 1020 | OP_ENDIF 1021 | OP_DEPTH 1022 | OP_2 1023 | OP_EQUAL 1024 | OP_IF 1025 | OP_0 1026 | OP_ROT 1027 | OP_ROT 1028 | OP_ENDIF 1029 | OP_3DUP 1030 | OP_SWAP 1031 | OP_IF 1032 | OP_BOOLAND 1033 | OP_NOT 1034 | OP_TOALTSTACK 1035 | OP_1 1036 | OP_ELSE 1037 | OP_TOALTSTACK 1038 | OP_ENDIF 1039 | OP_2DROP 1040 | OP_DEPTH 1041 | OP_1 1042 | OP_EQUAL 1043 | OP_IF 1044 | OP_0 1045 | OP_SWAP 1046 | OP_ENDIF 1047 | OP_DEPTH 1048 | OP_2 1049 | OP_EQUAL 1050 | OP_IF 1051 | OP_0 1052 | OP_ROT 1053 | OP_ROT 1054 | OP_ENDIF 1055 | OP_3DUP 1056 | OP_SWAP 1057 | OP_IF 1058 | OP_BOOLAND 1059 | OP_NOT 1060 | OP_TOALTSTACK 1061 | OP_1 1062 | OP_ELSE 1063 | OP_TOALTSTACK 1064 | OP_ENDIF 1065 | OP_2DROP 1066 | OP_DEPTH 1067 | OP_1 1068 | OP_EQUAL 1069 | OP_IF 1070 | OP_0 1071 | OP_SWAP 1072 | OP_ENDIF 1073 | OP_DEPTH 1074 | OP_2 1075 | OP_EQUAL 1076 | OP_IF 1077 | OP_0 1078 | OP_ROT 1079 | OP_ROT 1080 | OP_ENDIF 1081 | OP_2DROP 1082 | OP_DROP 1083 | OP_FROMALTSTACK 1084 | OP_FROMALTSTACK 1085 | OP_FROMALTSTACK 1086 | OP_FROMALTSTACK 1087 | OP_FROMALTSTACK 1088 | OP_FROMALTSTACK 1089 | OP_FROMALTSTACK 1090 | OP_FROMALTSTACK 1091 | OP_FROMALTSTACK 1092 | OP_FROMALTSTACK 1093 | OP_0 1094 | OP_3DUP 1095 | OP_SWAP 1096 | OP_IF 1097 | OP_BOOLAND 1098 | OP_NOT 1099 | OP_TOALTSTACK 1100 | OP_1 1101 | OP_ELSE 1102 | OP_TOALTSTACK 1103 | OP_ENDIF 1104 | OP_2DROP 1105 | OP_DEPTH 1106 | OP_1 1107 | OP_EQUAL 1108 | OP_IF 1109 | OP_0 1110 | OP_SWAP 1111 | OP_ENDIF 1112 | OP_DEPTH 1113 | OP_2 1114 | OP_EQUAL 1115 | OP_IF 1116 | OP_0 1117 | OP_ROT 1118 | OP_ROT 1119 | OP_ENDIF 1120 | OP_3DUP 1121 | OP_SWAP 1122 | OP_IF 1123 | OP_BOOLAND 1124 | OP_NOT 1125 | OP_TOALTSTACK 1126 | OP_1 1127 | OP_ELSE 1128 | OP_TOALTSTACK 1129 | OP_ENDIF 1130 | OP_2DROP 1131 | OP_DEPTH 1132 | OP_1 1133 | OP_EQUAL 1134 | OP_IF 1135 | OP_0 1136 | OP_SWAP 1137 | OP_ENDIF 1138 | OP_DEPTH 1139 | OP_2 1140 | OP_EQUAL 1141 | OP_IF 1142 | OP_0 1143 | OP_ROT 1144 | OP_ROT 1145 | OP_ENDIF 1146 | OP_3DUP 1147 | OP_SWAP 1148 | OP_IF 1149 | OP_BOOLAND 1150 | OP_NOT 1151 | OP_TOALTSTACK 1152 | OP_1 1153 | OP_ELSE 1154 | OP_TOALTSTACK 1155 | OP_ENDIF 1156 | OP_2DROP 1157 | OP_DEPTH 1158 | OP_1 1159 | OP_EQUAL 1160 | OP_IF 1161 | OP_0 1162 | OP_SWAP 1163 | OP_ENDIF 1164 | OP_DEPTH 1165 | OP_2 1166 | OP_EQUAL 1167 | OP_IF 1168 | OP_0 1169 | OP_ROT 1170 | OP_ROT 1171 | OP_ENDIF 1172 | OP_3DUP 1173 | OP_SWAP 1174 | OP_IF 1175 | OP_BOOLAND 1176 | OP_NOT 1177 | OP_TOALTSTACK 1178 | OP_1 1179 | OP_ELSE 1180 | OP_TOALTSTACK 1181 | OP_ENDIF 1182 | OP_2DROP 1183 | OP_DEPTH 1184 | OP_1 1185 | OP_EQUAL 1186 | OP_IF 1187 | OP_0 1188 | OP_SWAP 1189 | OP_ENDIF 1190 | OP_DEPTH 1191 | OP_2 1192 | OP_EQUAL 1193 | OP_IF 1194 | OP_0 1195 | OP_ROT 1196 | OP_ROT 1197 | OP_ENDIF 1198 | OP_3DUP 1199 | OP_SWAP 1200 | OP_IF 1201 | OP_BOOLAND 1202 | OP_NOT 1203 | OP_TOALTSTACK 1204 | OP_1 1205 | OP_ELSE 1206 | OP_TOALTSTACK 1207 | OP_ENDIF 1208 | OP_2DROP 1209 | OP_DEPTH 1210 | OP_1 1211 | OP_EQUAL 1212 | OP_IF 1213 | OP_0 1214 | OP_SWAP 1215 | OP_ENDIF 1216 | OP_DEPTH 1217 | OP_2 1218 | OP_EQUAL 1219 | OP_IF 1220 | OP_0 1221 | OP_ROT 1222 | OP_ROT 1223 | OP_ENDIF 1224 | OP_3DUP 1225 | OP_SWAP 1226 | OP_IF 1227 | OP_BOOLAND 1228 | OP_NOT 1229 | OP_TOALTSTACK 1230 | OP_1 1231 | OP_ELSE 1232 | OP_TOALTSTACK 1233 | OP_ENDIF 1234 | OP_2DROP 1235 | OP_DEPTH 1236 | OP_1 1237 | OP_EQUAL 1238 | OP_IF 1239 | OP_0 1240 | OP_SWAP 1241 | OP_ENDIF 1242 | OP_DEPTH 1243 | OP_2 1244 | OP_EQUAL 1245 | OP_IF 1246 | OP_0 1247 | OP_ROT 1248 | OP_ROT 1249 | OP_ENDIF 1250 | OP_3DUP 1251 | OP_SWAP 1252 | OP_IF 1253 | OP_BOOLAND 1254 | OP_NOT 1255 | OP_TOALTSTACK 1256 | OP_1 1257 | OP_ELSE 1258 | OP_TOALTSTACK 1259 | OP_ENDIF 1260 | OP_2DROP 1261 | OP_DEPTH 1262 | OP_1 1263 | OP_EQUAL 1264 | OP_IF 1265 | OP_0 1266 | OP_SWAP 1267 | OP_ENDIF 1268 | OP_DEPTH 1269 | OP_2 1270 | OP_EQUAL 1271 | OP_IF 1272 | OP_0 1273 | OP_ROT 1274 | OP_ROT 1275 | OP_ENDIF 1276 | OP_3DUP 1277 | OP_SWAP 1278 | OP_IF 1279 | OP_BOOLAND 1280 | OP_NOT 1281 | OP_TOALTSTACK 1282 | OP_1 1283 | OP_ELSE 1284 | OP_TOALTSTACK 1285 | OP_ENDIF 1286 | OP_2DROP 1287 | OP_DEPTH 1288 | OP_1 1289 | OP_EQUAL 1290 | OP_IF 1291 | OP_0 1292 | OP_SWAP 1293 | OP_ENDIF 1294 | OP_DEPTH 1295 | OP_2 1296 | OP_EQUAL 1297 | OP_IF 1298 | OP_0 1299 | OP_ROT 1300 | OP_ROT 1301 | OP_ENDIF 1302 | OP_3DUP 1303 | OP_SWAP 1304 | OP_IF 1305 | OP_BOOLAND 1306 | OP_NOT 1307 | OP_TOALTSTACK 1308 | OP_1 1309 | OP_ELSE 1310 | OP_TOALTSTACK 1311 | OP_ENDIF 1312 | OP_2DROP 1313 | OP_DEPTH 1314 | OP_1 1315 | OP_EQUAL 1316 | OP_IF 1317 | OP_0 1318 | OP_SWAP 1319 | OP_ENDIF 1320 | OP_DEPTH 1321 | OP_2 1322 | OP_EQUAL 1323 | OP_IF 1324 | OP_0 1325 | OP_ROT 1326 | OP_ROT 1327 | OP_ENDIF 1328 | OP_3DUP 1329 | OP_SWAP 1330 | OP_IF 1331 | OP_BOOLAND 1332 | OP_NOT 1333 | OP_TOALTSTACK 1334 | OP_1 1335 | OP_ELSE 1336 | OP_TOALTSTACK 1337 | OP_ENDIF 1338 | OP_2DROP 1339 | OP_DEPTH 1340 | OP_1 1341 | OP_EQUAL 1342 | OP_IF 1343 | OP_0 1344 | OP_SWAP 1345 | OP_ENDIF 1346 | OP_DEPTH 1347 | OP_2 1348 | OP_EQUAL 1349 | OP_IF 1350 | OP_0 1351 | OP_ROT 1352 | OP_ROT 1353 | OP_ENDIF 1354 | OP_2DROP 1355 | OP_DROP 1356 | OP_FROMALTSTACK 1357 | OP_FROMALTSTACK 1358 | OP_FROMALTSTACK 1359 | OP_FROMALTSTACK 1360 | OP_FROMALTSTACK 1361 | OP_FROMALTSTACK 1362 | OP_FROMALTSTACK 1363 | OP_FROMALTSTACK 1364 | OP_FROMALTSTACK 1365 | OP_FROMALTSTACK 1366 | OP_0 1367 | OP_3DUP 1368 | OP_SWAP 1369 | OP_IF 1370 | OP_BOOLAND 1371 | OP_NOT 1372 | OP_TOALTSTACK 1373 | OP_1 1374 | OP_ELSE 1375 | OP_TOALTSTACK 1376 | OP_ENDIF 1377 | OP_2DROP 1378 | OP_DEPTH 1379 | OP_1 1380 | OP_EQUAL 1381 | OP_IF 1382 | OP_0 1383 | OP_SWAP 1384 | OP_ENDIF 1385 | OP_DEPTH 1386 | OP_2 1387 | OP_EQUAL 1388 | OP_IF 1389 | OP_0 1390 | OP_ROT 1391 | OP_ROT 1392 | OP_ENDIF 1393 | OP_3DUP 1394 | OP_SWAP 1395 | OP_IF 1396 | OP_BOOLAND 1397 | OP_NOT 1398 | OP_TOALTSTACK 1399 | OP_1 1400 | OP_ELSE 1401 | OP_TOALTSTACK 1402 | OP_ENDIF 1403 | OP_2DROP 1404 | OP_DEPTH 1405 | OP_1 1406 | OP_EQUAL 1407 | OP_IF 1408 | OP_0 1409 | OP_SWAP 1410 | OP_ENDIF 1411 | OP_DEPTH 1412 | OP_2 1413 | OP_EQUAL 1414 | OP_IF 1415 | OP_0 1416 | OP_ROT 1417 | OP_ROT 1418 | OP_ENDIF 1419 | OP_3DUP 1420 | OP_SWAP 1421 | OP_IF 1422 | OP_BOOLAND 1423 | OP_NOT 1424 | OP_TOALTSTACK 1425 | OP_1 1426 | OP_ELSE 1427 | OP_TOALTSTACK 1428 | OP_ENDIF 1429 | OP_2DROP 1430 | OP_DEPTH 1431 | OP_1 1432 | OP_EQUAL 1433 | OP_IF 1434 | OP_0 1435 | OP_SWAP 1436 | OP_ENDIF 1437 | OP_DEPTH 1438 | OP_2 1439 | OP_EQUAL 1440 | OP_IF 1441 | OP_0 1442 | OP_ROT 1443 | OP_ROT 1444 | OP_ENDIF 1445 | OP_3DUP 1446 | OP_SWAP 1447 | OP_IF 1448 | OP_BOOLAND 1449 | OP_NOT 1450 | OP_TOALTSTACK 1451 | OP_1 1452 | OP_ELSE 1453 | OP_TOALTSTACK 1454 | OP_ENDIF 1455 | OP_2DROP 1456 | OP_DEPTH 1457 | OP_1 1458 | OP_EQUAL 1459 | OP_IF 1460 | OP_0 1461 | OP_SWAP 1462 | OP_ENDIF 1463 | OP_DEPTH 1464 | OP_2 1465 | OP_EQUAL 1466 | OP_IF 1467 | OP_0 1468 | OP_ROT 1469 | OP_ROT 1470 | OP_ENDIF 1471 | OP_3DUP 1472 | OP_SWAP 1473 | OP_IF 1474 | OP_BOOLAND 1475 | OP_NOT 1476 | OP_TOALTSTACK 1477 | OP_1 1478 | OP_ELSE 1479 | OP_TOALTSTACK 1480 | OP_ENDIF 1481 | OP_2DROP 1482 | OP_DEPTH 1483 | OP_1 1484 | OP_EQUAL 1485 | OP_IF 1486 | OP_0 1487 | OP_SWAP 1488 | OP_ENDIF 1489 | OP_DEPTH 1490 | OP_2 1491 | OP_EQUAL 1492 | OP_IF 1493 | OP_0 1494 | OP_ROT 1495 | OP_ROT 1496 | OP_ENDIF 1497 | OP_3DUP 1498 | OP_SWAP 1499 | OP_IF 1500 | OP_BOOLAND 1501 | OP_NOT 1502 | OP_TOALTSTACK 1503 | OP_1 1504 | OP_ELSE 1505 | OP_TOALTSTACK 1506 | OP_ENDIF 1507 | OP_2DROP 1508 | OP_DEPTH 1509 | OP_1 1510 | OP_EQUAL 1511 | OP_IF 1512 | OP_0 1513 | OP_SWAP 1514 | OP_ENDIF 1515 | OP_DEPTH 1516 | OP_2 1517 | OP_EQUAL 1518 | OP_IF 1519 | OP_0 1520 | OP_ROT 1521 | OP_ROT 1522 | OP_ENDIF 1523 | OP_3DUP 1524 | OP_SWAP 1525 | OP_IF 1526 | OP_BOOLAND 1527 | OP_NOT 1528 | OP_TOALTSTACK 1529 | OP_1 1530 | OP_ELSE 1531 | OP_TOALTSTACK 1532 | OP_ENDIF 1533 | OP_2DROP 1534 | OP_DEPTH 1535 | OP_1 1536 | OP_EQUAL 1537 | OP_IF 1538 | OP_0 1539 | OP_SWAP 1540 | OP_ENDIF 1541 | OP_DEPTH 1542 | OP_2 1543 | OP_EQUAL 1544 | OP_IF 1545 | OP_0 1546 | OP_ROT 1547 | OP_ROT 1548 | OP_ENDIF 1549 | OP_3DUP 1550 | OP_SWAP 1551 | OP_IF 1552 | OP_BOOLAND 1553 | OP_NOT 1554 | OP_TOALTSTACK 1555 | OP_1 1556 | OP_ELSE 1557 | OP_TOALTSTACK 1558 | OP_ENDIF 1559 | OP_2DROP 1560 | OP_DEPTH 1561 | OP_1 1562 | OP_EQUAL 1563 | OP_IF 1564 | OP_0 1565 | OP_SWAP 1566 | OP_ENDIF 1567 | OP_DEPTH 1568 | OP_2 1569 | OP_EQUAL 1570 | OP_IF 1571 | OP_0 1572 | OP_ROT 1573 | OP_ROT 1574 | OP_ENDIF 1575 | OP_3DUP 1576 | OP_SWAP 1577 | OP_IF 1578 | OP_BOOLAND 1579 | OP_NOT 1580 | OP_TOALTSTACK 1581 | OP_1 1582 | OP_ELSE 1583 | OP_TOALTSTACK 1584 | OP_ENDIF 1585 | OP_2DROP 1586 | OP_DEPTH 1587 | OP_1 1588 | OP_EQUAL 1589 | OP_IF 1590 | OP_0 1591 | OP_SWAP 1592 | OP_ENDIF 1593 | OP_DEPTH 1594 | OP_2 1595 | OP_EQUAL 1596 | OP_IF 1597 | OP_0 1598 | OP_ROT 1599 | OP_ROT 1600 | OP_ENDIF 1601 | OP_3DUP 1602 | OP_SWAP 1603 | OP_IF 1604 | OP_BOOLAND 1605 | OP_NOT 1606 | OP_TOALTSTACK 1607 | OP_1 1608 | OP_ELSE 1609 | OP_TOALTSTACK 1610 | OP_ENDIF 1611 | OP_2DROP 1612 | OP_DEPTH 1613 | OP_1 1614 | OP_EQUAL 1615 | OP_IF 1616 | OP_0 1617 | OP_SWAP 1618 | OP_ENDIF 1619 | OP_DEPTH 1620 | OP_2 1621 | OP_EQUAL 1622 | OP_IF 1623 | OP_0 1624 | OP_ROT 1625 | OP_ROT 1626 | OP_ENDIF 1627 | OP_2DROP 1628 | OP_DROP 1629 | OP_FROMALTSTACK 1630 | OP_FROMALTSTACK 1631 | OP_FROMALTSTACK 1632 | OP_FROMALTSTACK 1633 | OP_FROMALTSTACK 1634 | OP_FROMALTSTACK 1635 | OP_FROMALTSTACK 1636 | OP_FROMALTSTACK 1637 | OP_FROMALTSTACK 1638 | OP_FROMALTSTACK 1639 | OP_0 1640 | OP_3DUP 1641 | OP_SWAP 1642 | OP_IF 1643 | OP_BOOLAND 1644 | OP_NOT 1645 | OP_TOALTSTACK 1646 | OP_1 1647 | OP_ELSE 1648 | OP_TOALTSTACK 1649 | OP_ENDIF 1650 | OP_2DROP 1651 | OP_DEPTH 1652 | OP_1 1653 | OP_EQUAL 1654 | OP_IF 1655 | OP_0 1656 | OP_SWAP 1657 | OP_ENDIF 1658 | OP_DEPTH 1659 | OP_2 1660 | OP_EQUAL 1661 | OP_IF 1662 | OP_0 1663 | OP_ROT 1664 | OP_ROT 1665 | OP_ENDIF 1666 | OP_3DUP 1667 | OP_SWAP 1668 | OP_IF 1669 | OP_BOOLAND 1670 | OP_NOT 1671 | OP_TOALTSTACK 1672 | OP_1 1673 | OP_ELSE 1674 | OP_TOALTSTACK 1675 | OP_ENDIF 1676 | OP_2DROP 1677 | OP_DEPTH 1678 | OP_1 1679 | OP_EQUAL 1680 | OP_IF 1681 | OP_0 1682 | OP_SWAP 1683 | OP_ENDIF 1684 | OP_DEPTH 1685 | OP_2 1686 | OP_EQUAL 1687 | OP_IF 1688 | OP_0 1689 | OP_ROT 1690 | OP_ROT 1691 | OP_ENDIF 1692 | OP_3DUP 1693 | OP_SWAP 1694 | OP_IF 1695 | OP_BOOLAND 1696 | OP_NOT 1697 | OP_TOALTSTACK 1698 | OP_1 1699 | OP_ELSE 1700 | OP_TOALTSTACK 1701 | OP_ENDIF 1702 | OP_2DROP 1703 | OP_DEPTH 1704 | OP_1 1705 | OP_EQUAL 1706 | OP_IF 1707 | OP_0 1708 | OP_SWAP 1709 | OP_ENDIF 1710 | OP_DEPTH 1711 | OP_2 1712 | OP_EQUAL 1713 | OP_IF 1714 | OP_0 1715 | OP_ROT 1716 | OP_ROT 1717 | OP_ENDIF 1718 | OP_3DUP 1719 | OP_SWAP 1720 | OP_IF 1721 | OP_BOOLAND 1722 | OP_NOT 1723 | OP_TOALTSTACK 1724 | OP_1 1725 | OP_ELSE 1726 | OP_TOALTSTACK 1727 | OP_ENDIF 1728 | OP_2DROP 1729 | OP_DEPTH 1730 | OP_1 1731 | OP_EQUAL 1732 | OP_IF 1733 | OP_0 1734 | OP_SWAP 1735 | OP_ENDIF 1736 | OP_DEPTH 1737 | OP_2 1738 | OP_EQUAL 1739 | OP_IF 1740 | OP_0 1741 | OP_ROT 1742 | OP_ROT 1743 | OP_ENDIF 1744 | OP_3DUP 1745 | OP_SWAP 1746 | OP_IF 1747 | OP_BOOLAND 1748 | OP_NOT 1749 | OP_TOALTSTACK 1750 | OP_1 1751 | OP_ELSE 1752 | OP_TOALTSTACK 1753 | OP_ENDIF 1754 | OP_2DROP 1755 | OP_DEPTH 1756 | OP_1 1757 | OP_EQUAL 1758 | OP_IF 1759 | OP_0 1760 | OP_SWAP 1761 | OP_ENDIF 1762 | OP_DEPTH 1763 | OP_2 1764 | OP_EQUAL 1765 | OP_IF 1766 | OP_0 1767 | OP_ROT 1768 | OP_ROT 1769 | OP_ENDIF 1770 | OP_3DUP 1771 | OP_SWAP 1772 | OP_IF 1773 | OP_BOOLAND 1774 | OP_NOT 1775 | OP_TOALTSTACK 1776 | OP_1 1777 | OP_ELSE 1778 | OP_TOALTSTACK 1779 | OP_ENDIF 1780 | OP_2DROP 1781 | OP_DEPTH 1782 | OP_1 1783 | OP_EQUAL 1784 | OP_IF 1785 | OP_0 1786 | OP_SWAP 1787 | OP_ENDIF 1788 | OP_DEPTH 1789 | OP_2 1790 | OP_EQUAL 1791 | OP_IF 1792 | OP_0 1793 | OP_ROT 1794 | OP_ROT 1795 | OP_ENDIF 1796 | OP_3DUP 1797 | OP_SWAP 1798 | OP_IF 1799 | OP_BOOLAND 1800 | OP_NOT 1801 | OP_TOALTSTACK 1802 | OP_1 1803 | OP_ELSE 1804 | OP_TOALTSTACK 1805 | OP_ENDIF 1806 | OP_2DROP 1807 | OP_DEPTH 1808 | OP_1 1809 | OP_EQUAL 1810 | OP_IF 1811 | OP_0 1812 | OP_SWAP 1813 | OP_ENDIF 1814 | OP_DEPTH 1815 | OP_2 1816 | OP_EQUAL 1817 | OP_IF 1818 | OP_0 1819 | OP_ROT 1820 | OP_ROT 1821 | OP_ENDIF 1822 | OP_3DUP 1823 | OP_SWAP 1824 | OP_IF 1825 | OP_BOOLAND 1826 | OP_NOT 1827 | OP_TOALTSTACK 1828 | OP_1 1829 | OP_ELSE 1830 | OP_TOALTSTACK 1831 | OP_ENDIF 1832 | OP_2DROP 1833 | OP_DEPTH 1834 | OP_1 1835 | OP_EQUAL 1836 | OP_IF 1837 | OP_0 1838 | OP_SWAP 1839 | OP_ENDIF 1840 | OP_DEPTH 1841 | OP_2 1842 | OP_EQUAL 1843 | OP_IF 1844 | OP_0 1845 | OP_ROT 1846 | OP_ROT 1847 | OP_ENDIF 1848 | OP_3DUP 1849 | OP_SWAP 1850 | OP_IF 1851 | OP_BOOLAND 1852 | OP_NOT 1853 | OP_TOALTSTACK 1854 | OP_1 1855 | OP_ELSE 1856 | OP_TOALTSTACK 1857 | OP_ENDIF 1858 | OP_2DROP 1859 | OP_DEPTH 1860 | OP_1 1861 | OP_EQUAL 1862 | OP_IF 1863 | OP_0 1864 | OP_SWAP 1865 | OP_ENDIF 1866 | OP_DEPTH 1867 | OP_2 1868 | OP_EQUAL 1869 | OP_IF 1870 | OP_0 1871 | OP_ROT 1872 | OP_ROT 1873 | OP_ENDIF 1874 | OP_3DUP 1875 | OP_SWAP 1876 | OP_IF 1877 | OP_BOOLAND 1878 | OP_NOT 1879 | OP_TOALTSTACK 1880 | OP_1 1881 | OP_ELSE 1882 | OP_TOALTSTACK 1883 | OP_ENDIF 1884 | OP_2DROP 1885 | OP_DEPTH 1886 | OP_1 1887 | OP_EQUAL 1888 | OP_IF 1889 | OP_0 1890 | OP_SWAP 1891 | OP_ENDIF 1892 | OP_DEPTH 1893 | OP_2 1894 | OP_EQUAL 1895 | OP_IF 1896 | OP_0 1897 | OP_ROT 1898 | OP_ROT 1899 | OP_ENDIF 1900 | OP_2DROP 1901 | OP_DROP 1902 | OP_FROMALTSTACK 1903 | OP_FROMALTSTACK 1904 | OP_FROMALTSTACK 1905 | OP_FROMALTSTACK 1906 | OP_FROMALTSTACK 1907 | OP_FROMALTSTACK 1908 | OP_FROMALTSTACK 1909 | OP_FROMALTSTACK 1910 | OP_FROMALTSTACK 1911 | OP_FROMALTSTACK 1912 | OP_0 1913 | OP_3DUP 1914 | OP_SWAP 1915 | OP_IF 1916 | OP_BOOLAND 1917 | OP_NOT 1918 | OP_TOALTSTACK 1919 | OP_1 1920 | OP_ELSE 1921 | OP_TOALTSTACK 1922 | OP_ENDIF 1923 | OP_2DROP 1924 | OP_DEPTH 1925 | OP_1 1926 | OP_EQUAL 1927 | OP_IF 1928 | OP_0 1929 | OP_SWAP 1930 | OP_ENDIF 1931 | OP_DEPTH 1932 | OP_2 1933 | OP_EQUAL 1934 | OP_IF 1935 | OP_0 1936 | OP_ROT 1937 | OP_ROT 1938 | OP_ENDIF 1939 | OP_3DUP 1940 | OP_SWAP 1941 | OP_IF 1942 | OP_BOOLAND 1943 | OP_NOT 1944 | OP_TOALTSTACK 1945 | OP_1 1946 | OP_ELSE 1947 | OP_TOALTSTACK 1948 | OP_ENDIF 1949 | OP_2DROP 1950 | OP_DEPTH 1951 | OP_1 1952 | OP_EQUAL 1953 | OP_IF 1954 | OP_0 1955 | OP_SWAP 1956 | OP_ENDIF 1957 | OP_DEPTH 1958 | OP_2 1959 | OP_EQUAL 1960 | OP_IF 1961 | OP_0 1962 | OP_ROT 1963 | OP_ROT 1964 | OP_ENDIF 1965 | OP_3DUP 1966 | OP_SWAP 1967 | OP_IF 1968 | OP_BOOLAND 1969 | OP_NOT 1970 | OP_TOALTSTACK 1971 | OP_1 1972 | OP_ELSE 1973 | OP_TOALTSTACK 1974 | OP_ENDIF 1975 | OP_2DROP 1976 | OP_DEPTH 1977 | OP_1 1978 | OP_EQUAL 1979 | OP_IF 1980 | OP_0 1981 | OP_SWAP 1982 | OP_ENDIF 1983 | OP_DEPTH 1984 | OP_2 1985 | OP_EQUAL 1986 | OP_IF 1987 | OP_0 1988 | OP_ROT 1989 | OP_ROT 1990 | OP_ENDIF 1991 | OP_3DUP 1992 | OP_SWAP 1993 | OP_IF 1994 | OP_BOOLAND 1995 | OP_NOT 1996 | OP_TOALTSTACK 1997 | OP_1 1998 | OP_ELSE 1999 | OP_TOALTSTACK 2000 | OP_ENDIF 2001 | OP_2DROP 2002 | OP_DEPTH 2003 | OP_1 2004 | OP_EQUAL 2005 | OP_IF 2006 | OP_0 2007 | OP_SWAP 2008 | OP_ENDIF 2009 | OP_DEPTH 2010 | OP_2 2011 | OP_EQUAL 2012 | OP_IF 2013 | OP_0 2014 | OP_ROT 2015 | OP_ROT 2016 | OP_ENDIF 2017 | OP_3DUP 2018 | OP_SWAP 2019 | OP_IF 2020 | OP_BOOLAND 2021 | OP_NOT 2022 | OP_TOALTSTACK 2023 | OP_1 2024 | OP_ELSE 2025 | OP_TOALTSTACK 2026 | OP_ENDIF 2027 | OP_2DROP 2028 | OP_DEPTH 2029 | OP_1 2030 | OP_EQUAL 2031 | OP_IF 2032 | OP_0 2033 | OP_SWAP 2034 | OP_ENDIF 2035 | OP_DEPTH 2036 | OP_2 2037 | OP_EQUAL 2038 | OP_IF 2039 | OP_0 2040 | OP_ROT 2041 | OP_ROT 2042 | OP_ENDIF 2043 | OP_3DUP 2044 | OP_SWAP 2045 | OP_IF 2046 | OP_BOOLAND 2047 | OP_NOT 2048 | OP_TOALTSTACK 2049 | OP_1 2050 | OP_ELSE 2051 | OP_TOALTSTACK 2052 | OP_ENDIF 2053 | OP_2DROP 2054 | OP_DEPTH 2055 | OP_1 2056 | OP_EQUAL 2057 | OP_IF 2058 | OP_0 2059 | OP_SWAP 2060 | OP_ENDIF 2061 | OP_DEPTH 2062 | OP_2 2063 | OP_EQUAL 2064 | OP_IF 2065 | OP_0 2066 | OP_ROT 2067 | OP_ROT 2068 | OP_ENDIF 2069 | OP_3DUP 2070 | OP_SWAP 2071 | OP_IF 2072 | OP_BOOLAND 2073 | OP_NOT 2074 | OP_TOALTSTACK 2075 | OP_1 2076 | OP_ELSE 2077 | OP_TOALTSTACK 2078 | OP_ENDIF 2079 | OP_2DROP 2080 | OP_DEPTH 2081 | OP_1 2082 | OP_EQUAL 2083 | OP_IF 2084 | OP_0 2085 | OP_SWAP 2086 | OP_ENDIF 2087 | OP_DEPTH 2088 | OP_2 2089 | OP_EQUAL 2090 | OP_IF 2091 | OP_0 2092 | OP_ROT 2093 | OP_ROT 2094 | OP_ENDIF 2095 | OP_3DUP 2096 | OP_SWAP 2097 | OP_IF 2098 | OP_BOOLAND 2099 | OP_NOT 2100 | OP_TOALTSTACK 2101 | OP_1 2102 | OP_ELSE 2103 | OP_TOALTSTACK 2104 | OP_ENDIF 2105 | OP_2DROP 2106 | OP_DEPTH 2107 | OP_1 2108 | OP_EQUAL 2109 | OP_IF 2110 | OP_0 2111 | OP_SWAP 2112 | OP_ENDIF 2113 | OP_DEPTH 2114 | OP_2 2115 | OP_EQUAL 2116 | OP_IF 2117 | OP_0 2118 | OP_ROT 2119 | OP_ROT 2120 | OP_ENDIF 2121 | OP_3DUP 2122 | OP_SWAP 2123 | OP_IF 2124 | OP_BOOLAND 2125 | OP_NOT 2126 | OP_TOALTSTACK 2127 | OP_1 2128 | OP_ELSE 2129 | OP_TOALTSTACK 2130 | OP_ENDIF 2131 | OP_2DROP 2132 | OP_DEPTH 2133 | OP_1 2134 | OP_EQUAL 2135 | OP_IF 2136 | OP_0 2137 | OP_SWAP 2138 | OP_ENDIF 2139 | OP_DEPTH 2140 | OP_2 2141 | OP_EQUAL 2142 | OP_IF 2143 | OP_0 2144 | OP_ROT 2145 | OP_ROT 2146 | OP_ENDIF 2147 | OP_3DUP 2148 | OP_SWAP 2149 | OP_IF 2150 | OP_BOOLAND 2151 | OP_NOT 2152 | OP_TOALTSTACK 2153 | OP_1 2154 | OP_ELSE 2155 | OP_TOALTSTACK 2156 | OP_ENDIF 2157 | OP_2DROP 2158 | OP_DEPTH 2159 | OP_1 2160 | OP_EQUAL 2161 | OP_IF 2162 | OP_0 2163 | OP_SWAP 2164 | OP_ENDIF 2165 | OP_DEPTH 2166 | OP_2 2167 | OP_EQUAL 2168 | OP_IF 2169 | OP_0 2170 | OP_ROT 2171 | OP_ROT 2172 | OP_ENDIF 2173 | OP_2DROP 2174 | OP_DROP 2175 | OP_FROMALTSTACK 2176 | OP_FROMALTSTACK 2177 | OP_FROMALTSTACK 2178 | OP_FROMALTSTACK 2179 | OP_FROMALTSTACK 2180 | OP_FROMALTSTACK 2181 | OP_FROMALTSTACK 2182 | OP_FROMALTSTACK 2183 | OP_FROMALTSTACK 2184 | OP_FROMALTSTACK 2185 | OP_0 2186 | OP_3DUP 2187 | OP_SWAP 2188 | OP_IF 2189 | OP_BOOLAND 2190 | OP_NOT 2191 | OP_TOALTSTACK 2192 | OP_1 2193 | OP_ELSE 2194 | OP_TOALTSTACK 2195 | OP_ENDIF 2196 | OP_2DROP 2197 | OP_DEPTH 2198 | OP_1 2199 | OP_EQUAL 2200 | OP_IF 2201 | OP_0 2202 | OP_SWAP 2203 | OP_ENDIF 2204 | OP_DEPTH 2205 | OP_2 2206 | OP_EQUAL 2207 | OP_IF 2208 | OP_0 2209 | OP_ROT 2210 | OP_ROT 2211 | OP_ENDIF 2212 | OP_3DUP 2213 | OP_SWAP 2214 | OP_IF 2215 | OP_BOOLAND 2216 | OP_NOT 2217 | OP_TOALTSTACK 2218 | OP_1 2219 | OP_ELSE 2220 | OP_TOALTSTACK 2221 | OP_ENDIF 2222 | OP_2DROP 2223 | OP_DEPTH 2224 | OP_1 2225 | OP_EQUAL 2226 | OP_IF 2227 | OP_0 2228 | OP_SWAP 2229 | OP_ENDIF 2230 | OP_DEPTH 2231 | OP_2 2232 | OP_EQUAL 2233 | OP_IF 2234 | OP_0 2235 | OP_ROT 2236 | OP_ROT 2237 | OP_ENDIF 2238 | OP_3DUP 2239 | OP_SWAP 2240 | OP_IF 2241 | OP_BOOLAND 2242 | OP_NOT 2243 | OP_TOALTSTACK 2244 | OP_1 2245 | OP_ELSE 2246 | OP_TOALTSTACK 2247 | OP_ENDIF 2248 | OP_2DROP 2249 | OP_DEPTH 2250 | OP_1 2251 | OP_EQUAL 2252 | OP_IF 2253 | OP_0 2254 | OP_SWAP 2255 | OP_ENDIF 2256 | OP_DEPTH 2257 | OP_2 2258 | OP_EQUAL 2259 | OP_IF 2260 | OP_0 2261 | OP_ROT 2262 | OP_ROT 2263 | OP_ENDIF 2264 | OP_3DUP 2265 | OP_SWAP 2266 | OP_IF 2267 | OP_BOOLAND 2268 | OP_NOT 2269 | OP_TOALTSTACK 2270 | OP_1 2271 | OP_ELSE 2272 | OP_TOALTSTACK 2273 | OP_ENDIF 2274 | OP_2DROP 2275 | OP_DEPTH 2276 | OP_1 2277 | OP_EQUAL 2278 | OP_IF 2279 | OP_0 2280 | OP_SWAP 2281 | OP_ENDIF 2282 | OP_DEPTH 2283 | OP_2 2284 | OP_EQUAL 2285 | OP_IF 2286 | OP_0 2287 | OP_ROT 2288 | OP_ROT 2289 | OP_ENDIF 2290 | OP_3DUP 2291 | OP_SWAP 2292 | OP_IF 2293 | OP_BOOLAND 2294 | OP_NOT 2295 | OP_TOALTSTACK 2296 | OP_1 2297 | OP_ELSE 2298 | OP_TOALTSTACK 2299 | OP_ENDIF 2300 | OP_2DROP 2301 | OP_DEPTH 2302 | OP_1 2303 | OP_EQUAL 2304 | OP_IF 2305 | OP_0 2306 | OP_SWAP 2307 | OP_ENDIF 2308 | OP_DEPTH 2309 | OP_2 2310 | OP_EQUAL 2311 | OP_IF 2312 | OP_0 2313 | OP_ROT 2314 | OP_ROT 2315 | OP_ENDIF 2316 | OP_3DUP 2317 | OP_SWAP 2318 | OP_IF 2319 | OP_BOOLAND 2320 | OP_NOT 2321 | OP_TOALTSTACK 2322 | OP_1 2323 | OP_ELSE 2324 | OP_TOALTSTACK 2325 | OP_ENDIF 2326 | OP_2DROP 2327 | OP_DEPTH 2328 | OP_1 2329 | OP_EQUAL 2330 | OP_IF 2331 | OP_0 2332 | OP_SWAP 2333 | OP_ENDIF 2334 | OP_DEPTH 2335 | OP_2 2336 | OP_EQUAL 2337 | OP_IF 2338 | OP_0 2339 | OP_ROT 2340 | OP_ROT 2341 | OP_ENDIF 2342 | OP_3DUP 2343 | OP_SWAP 2344 | OP_IF 2345 | OP_BOOLAND 2346 | OP_NOT 2347 | OP_TOALTSTACK 2348 | OP_1 2349 | OP_ELSE 2350 | OP_TOALTSTACK 2351 | OP_ENDIF 2352 | OP_2DROP 2353 | OP_DEPTH 2354 | OP_1 2355 | OP_EQUAL 2356 | OP_IF 2357 | OP_0 2358 | OP_SWAP 2359 | OP_ENDIF 2360 | OP_DEPTH 2361 | OP_2 2362 | OP_EQUAL 2363 | OP_IF 2364 | OP_0 2365 | OP_ROT 2366 | OP_ROT 2367 | OP_ENDIF 2368 | OP_3DUP 2369 | OP_SWAP 2370 | OP_IF 2371 | OP_BOOLAND 2372 | OP_NOT 2373 | OP_TOALTSTACK 2374 | OP_1 2375 | OP_ELSE 2376 | OP_TOALTSTACK 2377 | OP_ENDIF 2378 | OP_2DROP 2379 | OP_DEPTH 2380 | OP_1 2381 | OP_EQUAL 2382 | OP_IF 2383 | OP_0 2384 | OP_SWAP 2385 | OP_ENDIF 2386 | OP_DEPTH 2387 | OP_2 2388 | OP_EQUAL 2389 | OP_IF 2390 | OP_0 2391 | OP_ROT 2392 | OP_ROT 2393 | OP_ENDIF 2394 | OP_3DUP 2395 | OP_SWAP 2396 | OP_IF 2397 | OP_BOOLAND 2398 | OP_NOT 2399 | OP_TOALTSTACK 2400 | OP_1 2401 | OP_ELSE 2402 | OP_TOALTSTACK 2403 | OP_ENDIF 2404 | OP_2DROP 2405 | OP_DEPTH 2406 | OP_1 2407 | OP_EQUAL 2408 | OP_IF 2409 | OP_0 2410 | OP_SWAP 2411 | OP_ENDIF 2412 | OP_DEPTH 2413 | OP_2 2414 | OP_EQUAL 2415 | OP_IF 2416 | OP_0 2417 | OP_ROT 2418 | OP_ROT 2419 | OP_ENDIF 2420 | OP_3DUP 2421 | OP_SWAP 2422 | OP_IF 2423 | OP_BOOLAND 2424 | OP_NOT 2425 | OP_TOALTSTACK 2426 | OP_1 2427 | OP_ELSE 2428 | OP_TOALTSTACK 2429 | OP_ENDIF 2430 | OP_2DROP 2431 | OP_DEPTH 2432 | OP_1 2433 | OP_EQUAL 2434 | OP_IF 2435 | OP_0 2436 | OP_SWAP 2437 | OP_ENDIF 2438 | OP_DEPTH 2439 | OP_2 2440 | OP_EQUAL 2441 | OP_IF 2442 | OP_0 2443 | OP_ROT 2444 | OP_ROT 2445 | OP_ENDIF 2446 | OP_2DROP 2447 | OP_DROP 2448 | OP_FROMALTSTACK 2449 | OP_FROMALTSTACK 2450 | OP_FROMALTSTACK 2451 | OP_FROMALTSTACK 2452 | OP_FROMALTSTACK 2453 | OP_FROMALTSTACK 2454 | OP_FROMALTSTACK 2455 | OP_FROMALTSTACK 2456 | OP_FROMALTSTACK 2457 | OP_FROMALTSTACK 2458 | OP_0 2459 | OP_3DUP 2460 | OP_SWAP 2461 | OP_IF 2462 | OP_BOOLAND 2463 | OP_NOT 2464 | OP_TOALTSTACK 2465 | OP_1 2466 | OP_ELSE 2467 | OP_TOALTSTACK 2468 | OP_ENDIF 2469 | OP_2DROP 2470 | OP_DEPTH 2471 | OP_1 2472 | OP_EQUAL 2473 | OP_IF 2474 | OP_0 2475 | OP_SWAP 2476 | OP_ENDIF 2477 | OP_DEPTH 2478 | OP_2 2479 | OP_EQUAL 2480 | OP_IF 2481 | OP_0 2482 | OP_ROT 2483 | OP_ROT 2484 | OP_ENDIF 2485 | OP_3DUP 2486 | OP_SWAP 2487 | OP_IF 2488 | OP_BOOLAND 2489 | OP_NOT 2490 | OP_TOALTSTACK 2491 | OP_1 2492 | OP_ELSE 2493 | OP_TOALTSTACK 2494 | OP_ENDIF 2495 | OP_2DROP 2496 | OP_DEPTH 2497 | OP_1 2498 | OP_EQUAL 2499 | OP_IF 2500 | OP_0 2501 | OP_SWAP 2502 | OP_ENDIF 2503 | OP_DEPTH 2504 | OP_2 2505 | OP_EQUAL 2506 | OP_IF 2507 | OP_0 2508 | OP_ROT 2509 | OP_ROT 2510 | OP_ENDIF 2511 | OP_3DUP 2512 | OP_SWAP 2513 | OP_IF 2514 | OP_BOOLAND 2515 | OP_NOT 2516 | OP_TOALTSTACK 2517 | OP_1 2518 | OP_ELSE 2519 | OP_TOALTSTACK 2520 | OP_ENDIF 2521 | OP_2DROP 2522 | OP_DEPTH 2523 | OP_1 2524 | OP_EQUAL 2525 | OP_IF 2526 | OP_0 2527 | OP_SWAP 2528 | OP_ENDIF 2529 | OP_DEPTH 2530 | OP_2 2531 | OP_EQUAL 2532 | OP_IF 2533 | OP_0 2534 | OP_ROT 2535 | OP_ROT 2536 | OP_ENDIF 2537 | OP_3DUP 2538 | OP_SWAP 2539 | OP_IF 2540 | OP_BOOLAND 2541 | OP_NOT 2542 | OP_TOALTSTACK 2543 | OP_1 2544 | OP_ELSE 2545 | OP_TOALTSTACK 2546 | OP_ENDIF 2547 | OP_2DROP 2548 | OP_DEPTH 2549 | OP_1 2550 | OP_EQUAL 2551 | OP_IF 2552 | OP_0 2553 | OP_SWAP 2554 | OP_ENDIF 2555 | OP_DEPTH 2556 | OP_2 2557 | OP_EQUAL 2558 | OP_IF 2559 | OP_0 2560 | OP_ROT 2561 | OP_ROT 2562 | OP_ENDIF 2563 | OP_3DUP 2564 | OP_SWAP 2565 | OP_IF 2566 | OP_BOOLAND 2567 | OP_NOT 2568 | OP_TOALTSTACK 2569 | OP_1 2570 | OP_ELSE 2571 | OP_TOALTSTACK 2572 | OP_ENDIF 2573 | OP_2DROP 2574 | OP_DEPTH 2575 | OP_1 2576 | OP_EQUAL 2577 | OP_IF 2578 | OP_0 2579 | OP_SWAP 2580 | OP_ENDIF 2581 | OP_DEPTH 2582 | OP_2 2583 | OP_EQUAL 2584 | OP_IF 2585 | OP_0 2586 | OP_ROT 2587 | OP_ROT 2588 | OP_ENDIF 2589 | OP_3DUP 2590 | OP_SWAP 2591 | OP_IF 2592 | OP_BOOLAND 2593 | OP_NOT 2594 | OP_TOALTSTACK 2595 | OP_1 2596 | OP_ELSE 2597 | OP_TOALTSTACK 2598 | OP_ENDIF 2599 | OP_2DROP 2600 | OP_DEPTH 2601 | OP_1 2602 | OP_EQUAL 2603 | OP_IF 2604 | OP_0 2605 | OP_SWAP 2606 | OP_ENDIF 2607 | OP_DEPTH 2608 | OP_2 2609 | OP_EQUAL 2610 | OP_IF 2611 | OP_0 2612 | OP_ROT 2613 | OP_ROT 2614 | OP_ENDIF 2615 | OP_3DUP 2616 | OP_SWAP 2617 | OP_IF 2618 | OP_BOOLAND 2619 | OP_NOT 2620 | OP_TOALTSTACK 2621 | OP_1 2622 | OP_ELSE 2623 | OP_TOALTSTACK 2624 | OP_ENDIF 2625 | OP_2DROP 2626 | OP_DEPTH 2627 | OP_1 2628 | OP_EQUAL 2629 | OP_IF 2630 | OP_0 2631 | OP_SWAP 2632 | OP_ENDIF 2633 | OP_DEPTH 2634 | OP_2 2635 | OP_EQUAL 2636 | OP_IF 2637 | OP_0 2638 | OP_ROT 2639 | OP_ROT 2640 | OP_ENDIF 2641 | OP_3DUP 2642 | OP_SWAP 2643 | OP_IF 2644 | OP_BOOLAND 2645 | OP_NOT 2646 | OP_TOALTSTACK 2647 | OP_1 2648 | OP_ELSE 2649 | OP_TOALTSTACK 2650 | OP_ENDIF 2651 | OP_2DROP 2652 | OP_DEPTH 2653 | OP_1 2654 | OP_EQUAL 2655 | OP_IF 2656 | OP_0 2657 | OP_SWAP 2658 | OP_ENDIF 2659 | OP_DEPTH 2660 | OP_2 2661 | OP_EQUAL 2662 | OP_IF 2663 | OP_0 2664 | OP_ROT 2665 | OP_ROT 2666 | OP_ENDIF 2667 | OP_3DUP 2668 | OP_SWAP 2669 | OP_IF 2670 | OP_BOOLAND 2671 | OP_NOT 2672 | OP_TOALTSTACK 2673 | OP_1 2674 | OP_ELSE 2675 | OP_TOALTSTACK 2676 | OP_ENDIF 2677 | OP_2DROP 2678 | OP_DEPTH 2679 | OP_1 2680 | OP_EQUAL 2681 | OP_IF 2682 | OP_0 2683 | OP_SWAP 2684 | OP_ENDIF 2685 | OP_DEPTH 2686 | OP_2 2687 | OP_EQUAL 2688 | OP_IF 2689 | OP_0 2690 | OP_ROT 2691 | OP_ROT 2692 | OP_ENDIF 2693 | OP_3DUP 2694 | OP_SWAP 2695 | OP_IF 2696 | OP_BOOLAND 2697 | OP_NOT 2698 | OP_TOALTSTACK 2699 | OP_1 2700 | OP_ELSE 2701 | OP_TOALTSTACK 2702 | OP_ENDIF 2703 | OP_2DROP 2704 | OP_DEPTH 2705 | OP_1 2706 | OP_EQUAL 2707 | OP_IF 2708 | OP_0 2709 | OP_SWAP 2710 | OP_ENDIF 2711 | OP_DEPTH 2712 | OP_2 2713 | OP_EQUAL 2714 | OP_IF 2715 | OP_0 2716 | OP_ROT 2717 | OP_ROT 2718 | OP_ENDIF 2719 | OP_2DROP 2720 | OP_DROP 2721 | OP_FROMALTSTACK 2722 | OP_FROMALTSTACK 2723 | OP_FROMALTSTACK 2724 | OP_FROMALTSTACK 2725 | OP_FROMALTSTACK 2726 | OP_FROMALTSTACK 2727 | OP_FROMALTSTACK 2728 | OP_FROMALTSTACK 2729 | OP_FROMALTSTACK 2730 | OP_FROMALTSTACK 2731 | OP_0 2732 | OP_3DUP 2733 | OP_SWAP 2734 | OP_IF 2735 | OP_BOOLAND 2736 | OP_NOT 2737 | OP_TOALTSTACK 2738 | OP_1 2739 | OP_ELSE 2740 | OP_TOALTSTACK 2741 | OP_ENDIF 2742 | OP_2DROP 2743 | OP_DEPTH 2744 | OP_1 2745 | OP_EQUAL 2746 | OP_IF 2747 | OP_0 2748 | OP_SWAP 2749 | OP_ENDIF 2750 | OP_DEPTH 2751 | OP_2 2752 | OP_EQUAL 2753 | OP_IF 2754 | OP_0 2755 | OP_ROT 2756 | OP_ROT 2757 | OP_ENDIF 2758 | OP_3DUP 2759 | OP_SWAP 2760 | OP_IF 2761 | OP_BOOLAND 2762 | OP_NOT 2763 | OP_TOALTSTACK 2764 | OP_1 2765 | OP_ELSE 2766 | OP_TOALTSTACK 2767 | OP_ENDIF 2768 | OP_2DROP 2769 | OP_DEPTH 2770 | OP_1 2771 | OP_EQUAL 2772 | OP_IF 2773 | OP_0 2774 | OP_SWAP 2775 | OP_ENDIF 2776 | OP_DEPTH 2777 | OP_2 2778 | OP_EQUAL 2779 | OP_IF 2780 | OP_0 2781 | OP_ROT 2782 | OP_ROT 2783 | OP_ENDIF 2784 | OP_3DUP 2785 | OP_SWAP 2786 | OP_IF 2787 | OP_BOOLAND 2788 | OP_NOT 2789 | OP_TOALTSTACK 2790 | OP_1 2791 | OP_ELSE 2792 | OP_TOALTSTACK 2793 | OP_ENDIF 2794 | OP_2DROP 2795 | OP_DEPTH 2796 | OP_1 2797 | OP_EQUAL 2798 | OP_IF 2799 | OP_0 2800 | OP_SWAP 2801 | OP_ENDIF 2802 | OP_DEPTH 2803 | OP_2 2804 | OP_EQUAL 2805 | OP_IF 2806 | OP_0 2807 | OP_ROT 2808 | OP_ROT 2809 | OP_ENDIF 2810 | OP_3DUP 2811 | OP_SWAP 2812 | OP_IF 2813 | OP_BOOLAND 2814 | OP_NOT 2815 | OP_TOALTSTACK 2816 | OP_1 2817 | OP_ELSE 2818 | OP_TOALTSTACK 2819 | OP_ENDIF 2820 | OP_2DROP 2821 | OP_DEPTH 2822 | OP_1 2823 | OP_EQUAL 2824 | OP_IF 2825 | OP_0 2826 | OP_SWAP 2827 | OP_ENDIF 2828 | OP_DEPTH 2829 | OP_2 2830 | OP_EQUAL 2831 | OP_IF 2832 | OP_0 2833 | OP_ROT 2834 | OP_ROT 2835 | OP_ENDIF 2836 | OP_3DUP 2837 | OP_SWAP 2838 | OP_IF 2839 | OP_BOOLAND 2840 | OP_NOT 2841 | OP_TOALTSTACK 2842 | OP_1 2843 | OP_ELSE 2844 | OP_TOALTSTACK 2845 | OP_ENDIF 2846 | OP_2DROP 2847 | OP_DEPTH 2848 | OP_1 2849 | OP_EQUAL 2850 | OP_IF 2851 | OP_0 2852 | OP_SWAP 2853 | OP_ENDIF 2854 | OP_DEPTH 2855 | OP_2 2856 | OP_EQUAL 2857 | OP_IF 2858 | OP_0 2859 | OP_ROT 2860 | OP_ROT 2861 | OP_ENDIF 2862 | OP_3DUP 2863 | OP_SWAP 2864 | OP_IF 2865 | OP_BOOLAND 2866 | OP_NOT 2867 | OP_TOALTSTACK 2868 | OP_1 2869 | OP_ELSE 2870 | OP_TOALTSTACK 2871 | OP_ENDIF 2872 | OP_2DROP 2873 | OP_DEPTH 2874 | OP_1 2875 | OP_EQUAL 2876 | OP_IF 2877 | OP_0 2878 | OP_SWAP 2879 | OP_ENDIF 2880 | OP_DEPTH 2881 | OP_2 2882 | OP_EQUAL 2883 | OP_IF 2884 | OP_0 2885 | OP_ROT 2886 | OP_ROT 2887 | OP_ENDIF 2888 | OP_3DUP 2889 | OP_SWAP 2890 | OP_IF 2891 | OP_BOOLAND 2892 | OP_NOT 2893 | OP_TOALTSTACK 2894 | OP_1 2895 | OP_ELSE 2896 | OP_TOALTSTACK 2897 | OP_ENDIF 2898 | OP_2DROP 2899 | OP_DEPTH 2900 | OP_1 2901 | OP_EQUAL 2902 | OP_IF 2903 | OP_0 2904 | OP_SWAP 2905 | OP_ENDIF 2906 | OP_DEPTH 2907 | OP_2 2908 | OP_EQUAL 2909 | OP_IF 2910 | OP_0 2911 | OP_ROT 2912 | OP_ROT 2913 | OP_ENDIF 2914 | OP_3DUP 2915 | OP_SWAP 2916 | OP_IF 2917 | OP_BOOLAND 2918 | OP_NOT 2919 | OP_TOALTSTACK 2920 | OP_1 2921 | OP_ELSE 2922 | OP_TOALTSTACK 2923 | OP_ENDIF 2924 | OP_2DROP 2925 | OP_DEPTH 2926 | OP_1 2927 | OP_EQUAL 2928 | OP_IF 2929 | OP_0 2930 | OP_SWAP 2931 | OP_ENDIF 2932 | OP_DEPTH 2933 | OP_2 2934 | OP_EQUAL 2935 | OP_IF 2936 | OP_0 2937 | OP_ROT 2938 | OP_ROT 2939 | OP_ENDIF 2940 | OP_3DUP 2941 | OP_SWAP 2942 | OP_IF 2943 | OP_BOOLAND 2944 | OP_NOT 2945 | OP_TOALTSTACK 2946 | OP_1 2947 | OP_ELSE 2948 | OP_TOALTSTACK 2949 | OP_ENDIF 2950 | OP_2DROP 2951 | OP_DEPTH 2952 | OP_1 2953 | OP_EQUAL 2954 | OP_IF 2955 | OP_0 2956 | OP_SWAP 2957 | OP_ENDIF 2958 | OP_DEPTH 2959 | OP_2 2960 | OP_EQUAL 2961 | OP_IF 2962 | OP_0 2963 | OP_ROT 2964 | OP_ROT 2965 | OP_ENDIF 2966 | OP_3DUP 2967 | OP_SWAP 2968 | OP_IF 2969 | OP_BOOLAND 2970 | OP_NOT 2971 | OP_TOALTSTACK 2972 | OP_1 2973 | OP_ELSE 2974 | OP_TOALTSTACK 2975 | OP_ENDIF 2976 | OP_2DROP 2977 | OP_DEPTH 2978 | OP_1 2979 | OP_EQUAL 2980 | OP_IF 2981 | OP_0 2982 | OP_SWAP 2983 | OP_ENDIF 2984 | OP_DEPTH 2985 | OP_2 2986 | OP_EQUAL 2987 | OP_IF 2988 | OP_0 2989 | OP_ROT 2990 | OP_ROT 2991 | OP_ENDIF 2992 | OP_2DROP 2993 | OP_DROP 2994 | OP_FROMALTSTACK 2995 | OP_FROMALTSTACK 2996 | OP_FROMALTSTACK 2997 | OP_FROMALTSTACK 2998 | OP_FROMALTSTACK 2999 | OP_FROMALTSTACK 3000 | OP_FROMALTSTACK 3001 | OP_FROMALTSTACK 3002 | OP_FROMALTSTACK 3003 | OP_FROMALTSTACK 3004 | ``` 3005 | --------------------------------------------------------------------------------