1106:
1313:. An illustration of this is the simple example of finding the correct path in a maze that contains a series of points, a starting point, several paths and a destination. If random paths must be chosen, then after following an incorrect path, there must be a method by which to return to the beginning of that path. This can be achieved through the use of stacks, as a last correct point can be pushed onto the stack, and popped from the stack in case of an incorrect path.
1343:
1511:
40:
1454:, the problem of finding, for each number in an array, the closest preceding number that is smaller than it. One algorithm for this problem uses a stack to maintain a collection of candidates for the nearest smaller value. For each position in the array, the stack is popped until a smaller value is found on its top, and then the value in the new position is pushed onto the stack.
1038:
implementation, at the end of a push operation, the stack pointer may point to the next unused location in the stack, or it may point to the topmost item in the stack. If the stack points to the current topmost item, the stack pointer will be updated before a new item is pushed onto the stack; if it points to the next available location in the stack, it will be updated
48:
1398:") to hold information about procedure/function calling and nesting in order to switch to the context of the called function and restore to the caller function when the calling finishes. The functions follow a runtime protocol between caller and callee to save arguments and return value on the stack. Stacks are an important way of supporting nested or
2442:
1491:
called it. An attacker can experiment to find a specific type of data that can be provided to such a program such that the return address of the current procedure is reset to point to an area within the stack itself (and within the data provided by the attacker), which in turn contains instructions that carry out unauthorized operations.
276:, as it is merely a special case of a list. In either case, what identifies the data structure as a stack is not the implementation but the interface: the user is only allowed to pop or push items onto the array or linked list, with few other helper operations. The following will demonstrate both implementations using
255:
to return the same data to the stack, it is not considered an essential operation. If the stack is empty, an underflow condition will occur upon execution of either the "stack top" or "pop" operations. Additionally, many implementations provide a check if the stack is empty and an operation that returns its size.
1498:
attack and is an extremely frequent source of security breaches in software, mainly because some of the most popular compilers use a shared stack for both data and procedure calls, and do not verify the length of data items. Frequently, programmers do not write code to verify the size of data items,
1490:
attack that takes advantage of this type of implementation by providing oversized data input to a program that does not check the length of input. Such a program may copy the data in its entirety to a location on the stack, and in doing so, it may change the return addresses for procedures that have
1033:
A stack is usually represented in computers by a block of memory cells, with the "bottom" at a fixed location, and the stack pointer holding the address of the current "top" cell in the stack. The "top" and "bottom" nomenclature is used irrespective of whether the stack actually grows towards higher
254:
In many implementations, a stack has more operations than the essential "push" and "pop" operations. An example of a non-essential operation is "top of stack", or "peek", which observes the top element without removing it from the stack. Since this can be broken down into a "pop" followed by a "push"
1482:
As an example, some programming languages use a common stack to store both data local to a called procedure and the linking information that allows the procedure to return to its caller. This means that the program moves data into and out of the same stack that contains critical return addresses for
949:
Stack pointers may point to the origin of a stack or to a limited range of addresses above or below the origin (depending on the direction in which the stack grows); however, the stack pointer cannot cross the origin of the stack. In other words, if the origin of the stack is at address 1000 and the
1350:
on the stack. A push operation decrements the pointer and copies the data to the stack; a pop operation copies data from the stack and then increments the pointer. Each procedure called in the program stores procedure return information (in yellow) and local data (in other colors) by pushing them
378:, it is possible to implement a stack that can grow or shrink as much as needed. The size of the stack is simply the size of the dynamic array, which is a very efficient implementation of a stack since adding items to or removing items from the end of a dynamic array requires amortized O(1) time.
1290:
use a stack structure to hold values. Expressions can be represented in prefix, postfix or infix notations and conversion from one form to another may be accomplished using a stack. Many compilers use a stack to parse syntax before translation into low-level code. Most programming languages are
1134:
Some machines use a stack for arithmetic and logical operations; operands are pushed onto the stack, and arithmetic and logical operations act on the top one or more items on the stack, popping them off the stack and pushing the result onto the stack. Machines that function in this fashion are
1016:
Stacks are often visualized growing from the bottom up (like real-world stacks). They may also be visualized growing from left to right, where the top is on the far right, or even growing from top to bottom. The important feature is for the bottom of the stack to be in a fixed position. The
1037:
Pushing an item on to the stack adjusts the stack pointer by the size of the item (either decrementing or incrementing, depending on the direction in which the stack grows in memory), pointing it to the next cell, and copies the new top item to the stack area. Depending again on the exact
245:
Stacks are often described using the analogy of a spring-loaded stack of plates in a cafeteria. Clean plates are placed on top of the stack, pushing down any plates already there. When the top plate is removed from the stack, the one below it is elevated to become the new top plate.
945:
There are many variations on the basic principle of stack operations. Every stack has a fixed location in memory at which it begins. As data items are added to the stack, the stack pointer is displaced to indicate the current extent of the stack, which expands away from the origin.
300:
that records the number of items pushed so far, therefore pointing to the place in the array where the next element is to be inserted (assuming a zero-based index convention). Thus, the stack itself can be effectively implemented as a three-element structure:
1483:
the procedure calls. If data is moved to the wrong location on the stack, or an oversized data item is moved to a stack location that is not large enough to contain it, return information for procedure calls may be corrupted, causing the program to fail.
950:
stack grows downwards (towards addresses 999, 998, and so on), the stack pointer must never be incremented beyond 1000 (to 1001 or beyond). If a pop operation on the stack causes the stack pointer to move past the origin of the stack, a
2446:
1320:, which finds all vertices of a graph that can be reached from a specified starting vertex. Other applications of backtracking involve searching through spaces that represent potential solutions to an optimization problem.
1405:
Some programming languages use the stack to store data that is local to a procedure. Space for local data items is allocated from the stack when the procedure is entered, and is deallocated when the procedure exits. The
1465:
based on maintaining a stack of clusters, each of which is the nearest neighbor of its predecessor on the stack. When this method finds a pair of clusters that are mutual nearest neighbors, they are popped and
1441:
of a two-dimensional system of points. A convex hull of a subset of the input is maintained in a stack, which is used to find and remove concavities in the boundary when a new point is added to the hull.
1346:
A typical call stack, storing local data and call information for multiple levels of procedure calls. This stack grows downward from its origin. The stack pointer points to the current topmost
1367:, meaning they define most basic operations (adding two numbers, printing a character) as taking their arguments from the stack, and placing any return values back on the stack. For example,
1017:
illustration in this section is an example of a top-to-bottom growth visualization: the top (28) is the stack "bottom", since the stack "top" (9) is where items are pushed or popped from.
1265:, implements a stack either directly in hardware or in RAM via a stack pointer, depending on the device. Many stack-based microprocessors were used to implement the programming language
1045:
Popping the stack is simply the inverse of pushing. The topmost item in the stack is removed and the stack pointer is updated, in the opposite order of that used in the push operation.
1402:
function calls. This type of stack is used implicitly by the compiler to support CALL and RETURN statements (or their equivalents) and is not manipulated directly by the programmer.
1727:
LaForest, Charles Eric (April 2007). "2.1 Lukasiewicz and the First
Generation: 2.1.2 Germany: Konrad Zuse (1910â1995); 2.2 The First Generation of Stack Computers: 2.2.1 Zuse Z4".
1105:
941:
operation: a data item at the current location to which the stack pointer points is read, and the stack pointer is moved by a distance corresponding to the size of that data item.
1120:, a 4-level-stack and could display two of four values of the stack registers X, Y, Z, and T at the same time due to its two-line display, here X and Y. In later models like the
1090:
1005:, items 1, 2, and 3 on the stack are moved to positions 2, 3, and 1 on the stack, respectively. Many variants of this operation are possible, with the most common being called
2016:
2109:
2054:
974:: the topmost item is inspected (or returned), but the stack pointer and stack size does not change (meaning the item remains on the stack). This can also be called the
1845:
2519:
141:
A stack may be implemented to have a bounded capacity. If the stack is full and does not contain enough space to accept another element, the stack is in a state of
417:
push(stk : stack, x : item): newhead â new frame newhead.data â x newhead.next â stk.head stk.head â newhead stk.size â stk.size + 1
1172:
architecture is an example of a set of registers organised as a stack where direct access to individual registers (relative to the current top) is also possible.
930:
operation: the address in the stack pointer is adjusted by the size of the data item and a data item is written at the location to which the stack pointer points.
1024:
will move the first element to the third position, the second to the first and the third to the second. Here are two equivalent visualizations of this process:
296:
being the first element pushed onto the stack and the last element popped off. The program must keep track of the size (length) of the stack, using a variable
1741:
2950:
2457:
1822:(Tagungsband zum Kolloquium 14. November 2014 in Jena). GI Series: Lecture Notes in Informatics (LNI) â Thematics (in German). Vol. T-7. Bonn, Germany:
1714:
919:) points to the most recently referenced location on the stack; when the stack has a size of zero, the stack pointer points to the origin of the stack.
1860:
2626:
1774:
2564:
2920:
2163:
1831:
1462:
1880:
2198:
411:
Pushing and popping items happens at the head of the list; overflow is not possible in this implementation (unless memory is exhausted):
1659:
1364:
1324:
is a technique for performing such backtracking searches without exhaustively searching all of the potential solutions in such a space.
1097:
CPU designs do not have dedicated stack instructions and therefore most, if not all, registers may be used as stack pointers as needed.
2406:
126:
Considered a sequential collection, a stack has one end which is the only position at which the push and pop operations may occur, the
2286:
2023:
1077:
stack pointer with dedicated call, return, push, and pop instructions that implicitly update the dedicated register, thus increasing
2859:
2560:
2494:
2097:
1921:
1624:
2512:
Friedrich L. Bauer's and Klaus
Samelson's works in the 1950s on the introduction of the terms cellar principle and cellar automaton
2089:
1410:
is typically implemented in this way. Using the same stack for both data and procedure calls has important security implications (
911:
A typical stack is an area of computer memory with a fixed origin and a variable size. Initially the size of the stack is zero. A
427:
stk.head = nil: report underflow error r â stk.head.data stk.head â stk.head.next stk.size â stk.size - 1
2507:
Friedrich L. Bauers und Klaus
Samelsons Arbeiten in den 1950er-Jahren zur EinfĂŒhrung der Begriffe Kellerprinzip und Kellerautomat
1571:
1540:
1458:
1094:
1054:
2649:
2481:
2050:
76:
1928:
Die
Bezeichnung 'Keller' hierfĂŒr wurde von Bauer und Samelson in einer deutschen Patentanmeldung vom 30. MĂ€rz 1957 eingefĂŒhrt.
1479:
and attacks. Programmers working in such environments must take special care to avoid such pitfalls in these implementations.
119:. As with a stack of physical objects, this structure makes it easy to take an item off the top of the stack, but accessing a
2654:
2019:
1809:
1823:
455:, make the stack operations push and pop available on their standard list/array types. Some languages, notably those in the
1232:
within a register-stack as another strategy to avoid the use of slow main memory for function arguments and return values.
2619:
1333:
898:
452:
2505:
954:
occurs. If a push operation causes the stack pointer to increment or decrement beyond the maximum extent of the stack, a
2984:
1266:
1078:
456:
2041:
2733:
2716:
1516:
648:
444:
197:
643:
390:. A stack is then a pointer to the "head" of the list, with perhaps a counter to keep track of the size of the list:
637:
2932:
2699:
2501:
2156:
1728:
1614:
1567:
1530:
1451:
1030:
cucumber apple banana ===left rotate==> cucumber apple banana
1027:
apple banana banana ===right rotate==> cucumber cucumber apple
97:
2689:
1979:
1706:
1649:(NB. Presented on 1946-03-19 before the Executive Committee of the National Physical Laboratory (Great Britain).)
2728:
2723:
2682:
2612:
1545:
1407:
968:: the top item is popped and then pushed twice, such that two copies of the former top item now lie at the top.
463:), are designed around language-defined stacks that are directly visible to and manipulated by the programmer.
2518:(in German). Jena, Germany: Institut fĂŒr Informatik, Christian-Albrechts-UniversitĂ€t zu Kiel. pp. 19â29.
1881:"Verfahren zur automatischen Verarbeitung von kodierten Daten und Rechenmaschine zur AusĂŒbung des Verfahrens"
2963:
2940:
2037:
1525:
1287:
1151:
1110:
1058:
222:
2093:
1499:
either, and when an oversized or undersized data item is copied to the stack, a security breach may occur.
612:
2945:
2745:
2376:
2228:
1970:
1944:
1901:
1872:
1737:
1414:) of which a programmer must be aware in order to avoid introducing serious security bugs into a program.
1371:
has a return stack and an operand stack, and also has a graphics state stack and a dictionary stack. Many
214:
31:
1426:
use a stack (separate from the usual function call stack of most programming languages) as the principal
2871:
2826:
2788:
1207:
1183:
218:
2546:
2367:(1993). "Optimal doubly logarithmic parallel algorithms based on finding all nearest smaller values".
1244:
1235:
There is also a number of small microprocessors that implement a stack directly in hardware, and some
226:
2811:
1672:
1663:
1640:
1602:
1380:
1360:
1292:
1093:, typically with a semi-dedicated stack pointer as well (such as A7 in the 68000). In contrast, most
269:
2381:
2273:
1769:(1957) . Written at Internationales Kolloquium ĂŒber Probleme der Rechentechnik, Dresden, Germany.
1240:
903:
A common use of stacks at the architecture level is as a means of allocating and accessing memory.
288:
An array can be used to implement a (bounded) stack, as follows. The first element, usually at the
2854:
2839:
2704:
2664:
2340:
2152:
1998:
1702:
1535:
1387:
1317:
916:
387:
193:
149:
135:
100:
operation can, without modifying the stack, return the value of the last element added. The name
72:
30:
This article is about the abstract concept. For some concrete uses of the term in computing, see
2088:(Habilitation thesis) (in German). Jena, Germany: Mathematisch-naturwissenschaftliche FakultÀt,
2083:
161:
2553:
History of informatics in German-speaking countries - Programming languages and compiler design
1351:
onto the stack. This type of stack implementation is extremely common, but it is vulnerable to
2773:
2672:
2490:
2259:
2255:
2243:
2194:
2169:
2159:
2121:
2079:
1917:
1837:
1827:
1620:
1476:
1210:) somewhat more complex to implement, although it is still feasible, as exemplified by modern
1203:
961:
Some environments that rely heavily on stacks may provide additional operations, for example:
231:
2589:
2796:
2421:
2386:
2324:
2188:
1988:
1681:
1645:
Proposals for
Development in the Mathematics Division of an Automatic Computing Engine (ACE)
1598:
1448:
for finding the row minima of a monotone matrix uses stacks in a similar way to Graham scan.
1321:
1258:
1159:
64:
2336:
2277:
1255:
1247:
2816:
2758:
2360:
2332:
2129:
1913:
1495:
1445:
1372:
1352:
1236:
1229:
1180:
353:
index after checking for underflow, and returns the item that was previously the top one:
170:
used the terms "bury" and "unbury" as a means of calling and returning from subroutines.
307:
stack: maxsize : integer top : integer items : array of item
2908:
2886:
2711:
2635:
2220:
2145:
1966:
1940:
1876:
1766:
1610:
1487:
1427:
1376:
1169:
1117:
189:
142:
2452:
17:
2978:
2881:
2778:
2763:
1337:
1195:
1191:
1190:, but it also prevents some types of optimizations possible on processors permitting
1136:
1129:
912:
375:
183:
175:
2002:
1342:
39:
2599:
2548:
Geschichte der deutschsprachigen
Informatik - Programmiersprachen und Ăbersetzerbau
2476:
2344:
2315:; Wilber, Robert (1987). "Geometric applications of a matrix-searching algorithm".
2308:
1947:(1959). "Sequentielle FormelĂŒbersetzung" [Sequential Formula Translation].
1310:
1304:
1187:
1176:
1147:
632:
2542:
1905:
108:
to a set of physical items stacked one atop another, such as a stack of plates.
2876:
2801:
2364:
2304:
1510:
1475:
Some computing environments use stacks in ways that may make them vulnerable to
1438:
1434:
1221:
1199:
467:
313:
initialize(stk : stack, size : integer): stk.items â new array of
289:
273:
210:
in 1957. In March 1988, by which time
Samelson was deceased, Bauer received the
179:
167:
43:
Similarly to a stack of plates, adding or removing is only practical at the top.
2128:. Elektronisches Rechnen und Regeln (in German). Vol. 1. Berlin, Germany:
111:
The order in which an element added to or removed from a stack is described as
2864:
2768:
2426:
2312:
1686:
1667:
1606:
1506:
1395:
1394:
receive their parameters and return resultsâ—âuse a special stack (the "
1391:
1368:
1251:
1225:
1074:
460:
448:
277:
171:
2279:
An
Efficient Algorithm for Determining the Convex Hull of a Finite Planar Set
1841:
2806:
2753:
1423:
1399:
1270:
1217:
1143:
998:
topmost items are moved on the stack in a rotating fashion. For example, if
2594:
2390:
1239:
have a fixed-depth stack that is not directly accessible. Examples are the
2903:
1993:
1974:
1779:(NB. This paper was first presented in 1955. It describes a number stack (
2849:
2677:
1811:
Keller, Stack und automatisches GedĂ€chtnis â eine
Struktur mit Potenzial
1808:
Fothe, Michael; Wilke, Thomas, eds. (2015) . Written at Jena, Germany.
2898:
2844:
2328:
2085:
Ziffern-Rechenautomat mit
Programmierung nach mathematischem Formelbild
1155:
1124:, the number of levels was increased to be only limited by memory size.
105:
47:
2893:
2834:
1262:
1113:
1082:
207:
123:
deeper in the stack may require removing multiple other items first.
2407:"A survey of recent advances in hierarchical clustering algorithms"
2285:. Information Processing Letters 1. Vol. 1. pp. 132â133.
1175:
Having the top-of-stack as an implicit argument allows for a small
2604:
1341:
1121:
1104:
1086:
627:
template class adapts existing containers to provide a restricted
408:
initialize(stk : stack): stk.head â nil stk.size â 0
46:
38:
2915:
2462:
2173:
1883:(in German). Munich, Germany: Deutsches Patentamt. DE-PS 1094019
1347:
1070:
440:
217:
for the invention of the stack principle. Similar concepts were
211:
120:
2608:
1816:
Cellar, stack and automatic memory - a structure with potential
2497:. Section 2.2.1: Stacks, Queues, and Deques, pp. 238â243.
1211:
1198:
for all (two or three) operands. A stack structure also makes
1166:
1066:
1062:
628:
367:: stk.top â stk.top â 1 r â stk.items
317:
items, initially empty stk.maxsize â size stk.top â 0
1619:(3rd ed.). MIT Press and McGraw-Hill. pp. 232â233.
474:" is the Lisp interpreter's prompt; lines not starting with "
166:
Stacks entered the computer science literature in 1946, when
402:
stack: head : frame or nil size : integer
2043:
An Addressless Coding Scheme based on Mathematical Notation
1430:
with which they organize their information. These include:
2559:(in German). Karlsruhe, Germany: FakultĂ€t fĂŒr Informatik,
2022:, Faculty of Computer Science. 1989-01-01. Archived from
1570:
operates first in, first out, referred to by the acronym
396:
frame: data : item next : frame or nil
338:
stk.top = stk.maxsize: report overflow error
1316:
The prototypical example of a backtracking algorithm is
1295:, allowing them to be parsed with stack-based machines.
466:
The following is an example of manipulating a stack in
546:;; get top (leftmost) element, should modify the stack
342:: stk.items â x stk.top â stk.top + 1
1091:
special addressing modes for implementation of stacks
988:: the two topmost items on the stack exchange places.
1912:(in German). Vol. Part 1 (3 ed.). Berlin:
268:
A stack can be easily implemented either through an
2931:
2825:
2787:
2744:
2663:
2642:
2017:"IEEE-Computer-Pioneer-Preis â Bauer, Friedrich L."
478:" are the interpreter's responses to expressions):
386:Another option for implementing stacks is to use a
2144:
623:operations with LIFO semantics; additionally, the
2600:Stack Size Analysis for Interrupt-driven Programs
922:The two operations applicable to all stacks are:
130:of the stack, and is fixed at the other end, the
2187:Godse, Atul P.; Godse, Deepali A. (2010-01-01).
363:stk.top = 0: report underflow error
134:. A stack may be implemented as, for example, a
92:, which removes the most recently added element.
1150:were stack machines, the most famous being the
851:// Prints the top of the stack ("D")
86:, which adds an element to the collection, and
51:Simple representation of a stack runtime with
2620:
2151:(1 ed.). Cambridge, Massachusetts, USA:
1730:Second-Generation Stack Computer Architecture
1711:Computer architecture: Concepts and evolution
1118:all of the company's calculators of that time
324:operation adds an element and increments the
8:
2458:Dictionary of Algorithms and Data Structures
1803:
1801:
1799:
1797:
1786:
1780:
237:
201:
1715:Addison-Wesley Longman Publishing Co., Inc.
1309:Another important application of stacks is
1261:. At least one microcontroller family, the
1228:are all examples of architectures that use
1073:, have a dedicated register for use as the
631:with only push/pop operations. PHP has an
334:push(stk : stack, x : item):
206:("operational cellar") in 1955 and filed a
2627:
2613:
2605:
2535:
1494:This type of attack is a variation on the
2425:
2380:
2225:Fundamentals of Data Structures in Pascal
2193:. Technical Publications. pp. 1â56.
1992:
1785:), but names it linear auxiliary memory (
1685:
1282:Expression evaluation and syntax parsing
1081:density. Some CISC processors, like the
881:// removing the next top ("C")
2489:, Third Edition. Addison-Wesley, 1997.
1910:Informatik â Eine einfĂŒhrende Ăbersicht
1775:VEB Deutscher Verlag der Wissenschaften
1587:
1559:
1375:are also stack-oriented, including the
1042:the new item is pushed onto the stack.
32:Stack (disambiguation) § Computing
1593:
1591:
1101:Stack in registers or dedicated memory
647:. Following is an example program in
79:of elements with two main operations:
1463:agglomerative hierarchical clustering
513:;; set the variable "stack"
7:
2504:(2015) . Written at Kiel, Germany.
1158:machines and the CISC machines from
818:// Insert "D" in the stack
797:// Insert "C" in the stack
776:// Insert "B" in the stack
755:// Insert "A" in the stack
328:index, after checking for overflow:
200:proposed the idea of a stack called
2094:urn:nbn:de:gbv:27-20130731-133019-7
1826:(GI) / Köllen Druck + Verlag GmbH.
1771:Probleme der Programmierungstechnik
1154:. Other examples include the CISC
866:// removing the top ("D")
138:with a pointer to the top element.
641:class that is a specialization of
25:
2561:Karlsruhe Institute of Technology
635:class. Java's library contains a
225:in the first half of 1954 and by
2445: This article incorporates
2440:
2292:from the original on 2022-10-22.
1975:"Sequential Formula Translation"
1541:FIFO (computing and electronics)
1509:
1486:Malicious parties may attempt a
1459:nearest-neighbor chain algorithm
591:;; push a new top onto the stack
435:Stacks and programming languages
178:had already been implemented in
2570:from the original on 2022-05-19
2525:from the original on 2022-11-14
2482:The Art of Computer Programming
2244:"Data Structures in a Nutshell"
2100:from the original on 2023-10-14
2060:from the original on 2020-04-12
2051:N.S.W. University of Technology
1851:from the original on 2020-04-12
1747:from the original on 2022-01-20
1707:Brooks, Jr., Frederick Phillips
1179:footprint with a good usage of
148:A stack is needed to implement
2147:Algorithms for RPN calculators
2090:Friedrich-Schiller-UniversitÀt
2020:Technical University of Munich
1773:(in German). Berlin, Germany:
1713:. Boston, Massachusetts, USA:
1328:Compile-time memory management
1111:programmable pocket calculator
292:, is the bottom, resulting in
242:("automatic memory") in 1958.
1:
2590:Stack Machines - the new wave
2534:(11 pages) (NB. Published in
1411:
1334:Stack-based memory allocation
907:Basic architecture of a stack
899:Stack-based memory allocation
115:, referred to by the acronym
1736:(thesis). Waterloo, Canada:
1548:(aka Automatic memory stack)
651:language, using that class.
2951:Directed acyclic word graph
2717:Double-ended priority queue
2157:John Wiley & Sons, Inc.
1949:Elektronische Rechenanlagen
1824:Gesellschaft fĂŒr Informatik
1517:Computer programming portal
1390:â—âthe ways in which
1116:from 1988 had, like nearly
558:;; check the value of stack
423:pop(stk : stack):
359:pop(stk : stack):
198:Technical University Munich
162:Jan Ćukasiewicz § Work
3001:
2274:Graham, Ronald "Ron" Lewis
2242:Pandey, Shreesham (2020).
1668:"The other Turing machine"
1616:Introduction to Algorithms
1452:All nearest smaller values
1331:
1302:
1127:
915:(usually in the form of a
896:
159:
29:
2959:
2053:. pp. 121-1â121-12.
1980:Communications of the ACM
2683:Retrieval Data Structure
2038:Hamblin, Charles Leonard
1546:Operational memory stack
1286:Calculators that employ
653:
480:
439:Some languages, such as
250:Non-essential operations
239:automatisches GedÀchtnis
2964:List of data structures
2941:Binary decision diagram
2427:10.1093/comjnl/26.4.354
2405:Murtagh, Fionn (1983).
1971:Bauer, Friedrich Ludwig
1945:Bauer, Friedrich Ludwig
1902:Bauer, Friedrich Ludwig
1873:Bauer, Friedrich Ludwig
1687:10.1093/comjnl/20.3.269
1660:Carpenter, Brian Edward
1526:List of data structures
1437:, an algorithm for the
1355:attacks (see the text).
1288:reverse Polish notation
1152:Burroughs large systems
1061:designs, including the
223:Charles Leonard Hamblin
2946:Directed acyclic graph
2487:Fundamental Algorithms
2447:public domain material
2391:10.1006/jagm.1993.1018
2229:Computer Science Press
2143:Ball, John A. (1978).
2126:Ziffernrechenautomaten
1788:linearer Hilfsspeicher
1787:
1781:
1738:University of Waterloo
1408:C programming language
1356:
1293:context-free languages
1277:Applications of stacks
1125:
238:
215:Computer Pioneer Award
202:
60:
44:
18:Stack (data structure)
2369:Journal of Algorithms
2190:Computer Architecture
1994:10.1145/366959.366968
1664:Doran, Robert William
1641:Turing, Alan Mathison
1603:Leiserson, Charles E.
1361:programming languages
1345:
1208:speculative execution
1202:implementations with
1108:
615:container types have
50:
42:
2812:Unrolled linked list
2595:Bounding stack depth
2414:The Computer Journal
1673:The Computer Journal
1418:Efficient algorithms
1381:Java Virtual Machine
1241:PIC microcontrollers
1049:Stack in main memory
613:C++ Standard Library
2985:Abstract data types
2860:Self-balancing tree
1703:Blaauw, Gerrit Anne
1388:calling conventions
2840:Binary search tree
2705:Double-ended queue
2329:10.1007/BF01840359
2153:Wiley-Interscience
1740:. pp. 8, 11.
1536:Double-ended queue
1357:
1318:depth-first search
1126:
1034:memory addresses.
917:processor register
459:family (including
388:singly linked list
194:Friedrich L. Bauer
150:depth-first search
136:singly linked list
113:last in, first out
73:abstract data type
61:
45:
27:Abstract data type
2972:
2971:
2774:Hashed array tree
2673:Associative array
2536:Fothe & Wilke
2165:978-0-471-03070-6
2122:KĂ€mmerer, Wilhelm
2096:. PPN:756275237.
2080:KĂ€mmerer, Wilhelm
1833:978-3-88579-426-4
1777:. pp. 61â68.
1607:Rivest, Ronald L.
1599:Cormen, Thomas H.
1477:security breaches
1214:implementations.
1204:register renaming
75:that serves as a
16:(Redirected from
2992:
2797:Association list
2629:
2622:
2615:
2606:
2578:
2576:
2575:
2569:
2558:
2533:
2531:
2530:
2524:
2517:
2466:
2444:
2443:
2433:
2431:
2429:
2411:
2402:
2396:
2394:
2384:
2361:Schieber, Baruch
2356:
2350:
2348:
2323:(1â4): 195â208.
2303:Aggarwal, Alok;
2300:
2294:
2293:
2291:
2284:
2270:
2264:
2263:
2239:
2233:
2232:
2217:
2211:
2210:
2208:
2207:
2200:978-8-18431534-9
2184:
2178:
2177:
2150:
2140:
2134:
2133:
2118:
2112:
2108:
2106:
2105:
2076:
2070:
2068:
2066:
2065:
2059:
2048:
2034:
2028:
2027:
2013:
2007:
2006:
1996:
1963:
1957:
1956:
1937:
1931:
1930:
1898:
1892:
1891:
1889:
1888:
1869:
1863:
1859:
1857:
1856:
1850:
1821:
1805:
1792:
1790:
1784:
1778:
1763:
1757:
1755:
1753:
1752:
1746:
1735:
1724:
1718:
1717:
1699:
1693:
1691:
1689:
1656:
1650:
1648:
1637:
1631:
1630:
1595:
1575:
1564:
1519:
1514:
1513:
1373:virtual machines
1322:Branch and bound
1245:Computer Cowboys
1237:microcontrollers
1230:register windows
1160:Tandem Computers
1004:
997:
992:Rotate (or Roll)
888:
885:
882:
879:
876:
873:
870:
867:
864:
861:
858:
855:
852:
849:
846:
843:
840:
837:
834:
831:
828:
825:
822:
819:
816:
813:
810:
807:
804:
801:
798:
795:
792:
789:
786:
783:
780:
777:
774:
771:
768:
765:
762:
759:
756:
753:
750:
747:
744:
741:
738:
735:
732:
729:
726:
723:
720:
717:
714:
711:
708:
705:
702:
699:
696:
693:
690:
687:
684:
681:
678:
675:
672:
669:
666:
663:
660:
657:
646:
640:
626:
622:
618:
607:
604:
601:
598:
595:
592:
589:
586:
583:
580:
577:
574:
571:
568:
565:
562:
559:
556:
553:
550:
547:
544:
541:
538:
535:
532:
529:
526:
523:
520:
517:
514:
511:
508:
505:
502:
499:
496:
493:
490:
487:
484:
477:
473:
295:
241:
235:
227:Wilhelm KĂ€mmerer
205:
203:Operationskeller
174:and a two-level
96:Additionally, a
65:computer science
21:
3000:
2999:
2995:
2994:
2993:
2991:
2990:
2989:
2975:
2974:
2973:
2968:
2955:
2927:
2821:
2817:XOR linked list
2783:
2759:Circular buffer
2740:
2659:
2638:
2636:Data structures
2633:
2586:
2573:
2571:
2567:
2556:
2541:
2528:
2526:
2522:
2515:
2502:Langmaack, Hans
2500:
2473:
2471:Further reading
2453:"Bounded stack"
2451:Paul E. Black.
2450:
2441:
2437:
2436:
2409:
2404:
2403:
2399:
2359:Berkman, Omer;
2358:
2357:
2353:
2305:Klawe, Maria M.
2302:
2301:
2297:
2289:
2282:
2272:
2271:
2267:
2241:
2240:
2236:
2221:Horowitz, Ellis
2219:
2218:
2214:
2205:
2203:
2201:
2186:
2185:
2181:
2166:
2142:
2141:
2137:
2130:Akademie-Verlag
2120:
2119:
2115:
2103:
2101:
2078:
2077:
2073:
2063:
2061:
2057:
2046:
2036:
2035:
2031:
2015:
2014:
2010:
1967:Samelson, Klaus
1965:
1964:
1960:
1941:Samelson, Klaus
1939:
1938:
1934:
1924:
1916:. p. 222.
1914:Springer-Verlag
1900:
1899:
1895:
1886:
1884:
1877:Samelson, Klaus
1871:
1870:
1866:
1854:
1852:
1848:
1834:
1819:
1807:
1806:
1795:
1767:Samelson, Klaus
1765:
1764:
1760:
1750:
1748:
1744:
1733:
1726:
1725:
1721:
1701:
1700:
1696:
1666:(1977-01-01) .
1658:
1657:
1653:
1643:(1946-03-19) .
1639:
1638:
1634:
1627:
1611:Stein, Clifford
1597:
1596:
1589:
1584:
1579:
1578:
1566:By contrast, a
1565:
1561:
1556:
1551:
1515:
1508:
1505:
1496:buffer overflow
1473:
1461:, a method for
1446:SMAWK algorithm
1420:
1353:buffer overflow
1340:
1332:Main articles:
1330:
1307:
1301:
1284:
1279:
1132:
1103:
1051:
1031:
1028:
999:
995:
952:stack underflow
909:
901:
895:
890:
889:
886:
883:
880:
877:
874:
871:
868:
865:
862:
859:
856:
853:
850:
847:
844:
841:
838:
835:
832:
829:
826:
823:
820:
817:
814:
811:
808:
805:
802:
799:
796:
793:
790:
787:
784:
781:
778:
775:
772:
769:
766:
763:
760:
757:
754:
751:
748:
745:
742:
739:
736:
733:
730:
727:
724:
721:
718:
715:
712:
709:
706:
703:
700:
697:
694:
691:
688:
685:
682:
679:
676:
673:
670:
667:
664:
661:
659:java.util.Stack
658:
655:
642:
636:
624:
620:
616:
611:Several of the
609:
608:
605:
602:
599:
596:
593:
590:
587:
584:
581:
578:
575:
572:
569:
566:
563:
560:
557:
554:
551:
548:
545:
542:
539:
536:
533:
530:
527:
524:
521:
518:
515:
512:
509:
506:
503:
500:
497:
494:
491:
488:
485:
482:
475:
471:
437:
432:
418:
409:
403:
397:
384:
372:
349:decrements the
343:
318:
308:
293:
286:
266:
261:
259:Software stacks
252:
229:
164:
158:
35:
28:
23:
22:
15:
12:
11:
5:
2998:
2996:
2988:
2987:
2977:
2976:
2970:
2969:
2967:
2966:
2960:
2957:
2956:
2954:
2953:
2948:
2943:
2937:
2935:
2929:
2928:
2926:
2925:
2924:
2923:
2913:
2912:
2911:
2909:Hilbert R-tree
2906:
2901:
2891:
2890:
2889:
2887:Fibonacci heap
2884:
2879:
2869:
2868:
2867:
2862:
2857:
2855:Redâblack tree
2852:
2847:
2837:
2831:
2829:
2823:
2822:
2820:
2819:
2814:
2809:
2804:
2799:
2793:
2791:
2785:
2784:
2782:
2781:
2776:
2771:
2766:
2761:
2756:
2750:
2748:
2742:
2741:
2739:
2738:
2737:
2736:
2731:
2721:
2720:
2719:
2712:Priority queue
2709:
2708:
2707:
2697:
2692:
2687:
2686:
2685:
2680:
2669:
2667:
2661:
2660:
2658:
2657:
2652:
2646:
2644:
2640:
2639:
2634:
2632:
2631:
2624:
2617:
2609:
2603:
2602:
2597:
2592:
2585:
2584:External links
2582:
2581:
2580:
2545:(2017-08-07).
2539:
2498:
2472:
2469:
2468:
2467:
2435:
2434:
2420:(4): 354â359.
2397:
2382:10.1.1.55.5669
2375:(3): 344â370.
2351:
2295:
2265:
2234:
2212:
2199:
2179:
2164:
2135:
2113:
2082:(1958-12-11).
2071:
2049:(typescript).
2029:
2026:on 2017-11-07.
2008:
1958:
1932:
1922:
1893:
1879:(1957-03-30).
1864:
1832:
1793:
1758:
1719:
1694:
1680:(3): 269â279.
1651:
1632:
1625:
1586:
1585:
1583:
1580:
1577:
1576:
1558:
1557:
1555:
1552:
1550:
1549:
1543:
1538:
1533:
1528:
1522:
1521:
1520:
1504:
1501:
1488:stack smashing
1472:
1469:
1468:
1467:
1455:
1449:
1442:
1428:data structure
1419:
1416:
1377:p-code machine
1365:stack-oriented
1329:
1326:
1303:Main article:
1300:
1297:
1283:
1280:
1278:
1275:
1254:line, and the
1170:floating point
1137:stack machines
1128:Main article:
1102:
1099:
1050:
1047:
1029:
1026:
1014:
1013:
989:
979:
969:
956:stack overflow
943:
942:
931:
908:
905:
897:Main article:
894:
893:Hardware stack
891:
654:
481:
436:
433:
419:
413:
404:
398:
392:
383:
380:
355:
330:
309:
303:
285:
282:
265:
264:Implementation
262:
260:
257:
251:
248:
190:Klaus Samelson
157:
154:
143:stack overflow
94:
93:
87:
26:
24:
14:
13:
10:
9:
6:
4:
3:
2:
2997:
2986:
2983:
2982:
2980:
2965:
2962:
2961:
2958:
2952:
2949:
2947:
2944:
2942:
2939:
2938:
2936:
2934:
2930:
2922:
2919:
2918:
2917:
2914:
2910:
2907:
2905:
2902:
2900:
2897:
2896:
2895:
2892:
2888:
2885:
2883:
2882:Binomial heap
2880:
2878:
2875:
2874:
2873:
2870:
2866:
2863:
2861:
2858:
2856:
2853:
2851:
2848:
2846:
2843:
2842:
2841:
2838:
2836:
2833:
2832:
2830:
2828:
2824:
2818:
2815:
2813:
2810:
2808:
2805:
2803:
2800:
2798:
2795:
2794:
2792:
2790:
2786:
2780:
2779:Sparse matrix
2777:
2775:
2772:
2770:
2767:
2765:
2764:Dynamic array
2762:
2760:
2757:
2755:
2752:
2751:
2749:
2747:
2743:
2735:
2732:
2730:
2727:
2726:
2725:
2722:
2718:
2715:
2714:
2713:
2710:
2706:
2703:
2702:
2701:
2698:
2696:
2693:
2691:
2688:
2684:
2681:
2679:
2676:
2675:
2674:
2671:
2670:
2668:
2666:
2662:
2656:
2653:
2651:
2648:
2647:
2645:
2641:
2637:
2630:
2625:
2623:
2618:
2616:
2611:
2610:
2607:
2601:
2598:
2596:
2593:
2591:
2588:
2587:
2583:
2566:
2562:
2554:
2550:
2549:
2544:
2543:Goos, Gerhard
2540:
2537:
2521:
2513:
2509:
2508:
2503:
2499:
2496:
2495:0-201-89683-4
2492:
2488:
2484:
2483:
2478:
2475:
2474:
2470:
2464:
2460:
2459:
2454:
2448:
2439:
2438:
2428:
2423:
2419:
2415:
2408:
2401:
2398:
2392:
2388:
2383:
2378:
2374:
2370:
2366:
2362:
2355:
2352:
2346:
2342:
2338:
2334:
2330:
2326:
2322:
2318:
2314:
2310:
2309:Moran, Shlomo
2306:
2299:
2296:
2288:
2281:
2280:
2275:
2269:
2266:
2261:
2257:
2253:
2249:
2245:
2238:
2235:
2231:. p. 67.
2230:
2226:
2222:
2216:
2213:
2202:
2196:
2192:
2191:
2183:
2180:
2175:
2171:
2167:
2161:
2158:
2154:
2149:
2148:
2139:
2136:
2131:
2127:
2123:
2117:
2114:
2110:
2099:
2095:
2091:
2087:
2086:
2081:
2075:
2072:
2056:
2052:
2045:
2044:
2039:
2033:
2030:
2025:
2021:
2018:
2012:
2009:
2004:
2000:
1995:
1990:
1986:
1982:
1981:
1976:
1972:
1968:
1962:
1959:
1955:(4): 176â182.
1954:
1951:(in German).
1950:
1946:
1942:
1936:
1933:
1929:
1925:
1923:3-540-11722-9
1919:
1915:
1911:
1907:
1906:Goos, Gerhard
1903:
1897:
1894:
1882:
1878:
1874:
1868:
1865:
1861:
1847:
1843:
1839:
1835:
1829:
1825:
1817:
1813:
1812:
1804:
1802:
1800:
1798:
1794:
1789:
1783:
1776:
1772:
1768:
1762:
1759:
1743:
1739:
1732:
1731:
1723:
1720:
1716:
1712:
1708:
1704:
1698:
1695:
1688:
1683:
1679:
1675:
1674:
1669:
1665:
1661:
1655:
1652:
1646:
1642:
1636:
1633:
1628:
1626:0-262-03384-4
1622:
1618:
1617:
1612:
1608:
1604:
1600:
1594:
1592:
1588:
1581:
1573:
1569:
1563:
1560:
1553:
1547:
1544:
1542:
1539:
1537:
1534:
1532:
1529:
1527:
1524:
1523:
1518:
1512:
1507:
1502:
1500:
1497:
1492:
1489:
1484:
1480:
1478:
1470:
1464:
1460:
1456:
1453:
1450:
1447:
1443:
1440:
1436:
1433:
1432:
1431:
1429:
1425:
1417:
1415:
1413:
1409:
1403:
1401:
1397:
1393:
1389:
1384:
1382:
1378:
1374:
1370:
1366:
1362:
1354:
1349:
1344:
1339:
1338:Stack machine
1335:
1327:
1325:
1323:
1319:
1314:
1312:
1306:
1298:
1296:
1294:
1289:
1281:
1276:
1274:
1272:
1268:
1264:
1260:
1257:
1253:
1249:
1246:
1242:
1238:
1233:
1231:
1227:
1223:
1219:
1215:
1213:
1209:
1205:
1201:
1197:
1196:register file
1193:
1192:random access
1189:
1185:
1182:
1178:
1173:
1171:
1168:
1163:
1161:
1157:
1153:
1149:
1148:minicomputers
1145:
1140:
1138:
1131:
1130:Stack machine
1123:
1119:
1115:
1112:
1107:
1100:
1098:
1096:
1092:
1088:
1084:
1080:
1076:
1072:
1068:
1064:
1060:
1056:
1048:
1046:
1043:
1041:
1035:
1025:
1023:
1018:
1012:
1011:right rotate.
1008:
1002:
993:
990:
987:
983:
980:
977:
973:
970:
967:
964:
963:
962:
959:
957:
953:
947:
940:
936:
932:
929:
925:
924:
923:
920:
918:
914:
913:stack pointer
906:
904:
900:
892:
812:"D"
791:"C"
770:"B"
749:"A"
652:
650:
645:
639:
634:
630:
614:
479:
469:
464:
462:
458:
454:
450:
446:
442:
434:
430:
426:
422:
416:
412:
407:
401:
395:
391:
389:
381:
379:
377:
376:dynamic array
370:
366:
362:
358:
354:
352:
348:
341:
337:
333:
329:
327:
323:
316:
312:
306:
302:
299:
291:
283:
281:
279:
275:
271:
263:
258:
256:
249:
247:
243:
240:
233:
228:
224:
221:developed by
220:
219:independently
216:
213:
209:
204:
199:
195:
191:
187:
185:
181:
177:
173:
169:
163:
155:
153:
151:
146:
144:
139:
137:
133:
129:
124:
122:
118:
114:
109:
107:
103:
99:
91:
88:
85:
82:
81:
80:
78:
74:
70:
66:
58:
54:
49:
41:
37:
33:
19:
2734:Disjoint-set
2694:
2572:. Retrieved
2552:
2547:
2527:. Retrieved
2511:
2506:
2486:
2485:, Volume 1:
2480:
2477:Donald Knuth
2456:
2417:
2413:
2400:
2372:
2368:
2365:Vishkin, Uzi
2354:
2320:
2317:Algorithmica
2316:
2298:
2278:
2268:
2251:
2247:
2237:
2224:
2215:
2204:. Retrieved
2189:
2182:
2146:
2138:
2125:
2116:
2111:(2+69 pages)
2102:. Retrieved
2084:
2074:
2062:. Retrieved
2042:
2040:(May 1957).
2032:
2024:the original
2011:
1987:(2): 76â83.
1984:
1978:
1961:
1952:
1948:
1935:
1927:
1909:
1896:
1885:. Retrieved
1867:
1853:. Retrieved
1815:
1810:
1782:Zahlenkeller
1770:
1761:
1749:. Retrieved
1729:
1722:
1710:
1697:
1677:
1671:
1654:
1644:
1635:
1615:
1562:
1493:
1485:
1481:
1474:
1444:Part of the
1421:
1404:
1385:
1359:A number of
1358:
1315:
1311:backtracking
1308:
1305:Backtracking
1299:Backtracking
1285:
1234:
1216:
1177:machine code
1174:
1164:
1142:A number of
1141:
1133:
1089:, also have
1052:
1044:
1039:
1036:
1032:
1022:right rotate
1021:
1019:
1015:
1010:
1006:
1000:
991:
985:
981:
975:
971:
965:
960:
955:
951:
948:
944:
938:
934:
927:
921:
910:
902:
610:
465:
438:
428:
424:
420:
414:
410:
405:
399:
393:
385:
373:
368:
364:
360:
356:
350:
346:
344:
339:
335:
331:
325:
321:
319:
314:
310:
304:
297:
287:
267:
253:
244:
188:
165:
147:
140:
131:
127:
125:
116:
112:
110:
101:
95:
89:
83:
68:
62:
56:
52:
36:
2877:Binary heap
2802:Linked list
2313:Shor, Peter
1756:(178 pages)
1439:convex hull
1435:Graham scan
1392:subroutines
1386:Almost all
1222:AMD Am29000
1200:superscalar
1188:code caches
1007:left rotate
468:Common Lisp
382:Linked list
345:Similarly,
290:zero offset
274:linked list
230: [
180:Konrad Zuse
172:Subroutines
168:Alan Turing
59:operations.
2865:Splay tree
2769:Hash table
2650:Collection
2579:(11 pages)
2574:2022-11-14
2529:2022-11-14
2248:Dev Genius
2206:2015-01-30
2104:2023-10-14
2069:(12 pages)
2064:2020-04-12
1887:2010-10-01
1862:(77 pages)
1855:2020-04-12
1751:2022-07-02
1692:(11 pages)
1582:References
1424:algorithms
1396:call stack
1369:PostScript
1252:Harris RTX
1226:Intel i960
1144:mainframes
1075:call stack
978:operation.
461:PostScript
449:JavaScript
278:pseudocode
160:See also:
77:collection
2921:Hash tree
2807:Skip list
2754:Bit array
2655:Container
2377:CiteSeerX
1842:1614-3213
1613:(2009) .
1412:see below
1400:recursive
1271:microcode
1218:Sun SPARC
1184:bandwidth
966:Duplicate
668:StackDemo
617:push_back
421:procedure
415:procedure
406:procedure
400:structure
394:structure
357:procedure
332:procedure
311:procedure
305:structure
236:with his
186:in 1945.
2979:Category
2850:AVL tree
2729:Multiset
2678:Multimap
2665:Abstract
2565:Archived
2520:Archived
2287:Archived
2276:(1972).
2223:(1984).
2174:77-14977
2124:(1960).
2098:Archived
2055:Archived
2003:16646147
1973:(1960).
1908:(1982).
1846:Archived
1742:Archived
1709:(1997).
1503:See also
1471:Security
1422:Several
1379:and the
1085:and the
986:exchange
958:occurs.
633:SplStack
621:pop_back
582:'new
374:Using a
2904:R+ tree
2899:R* tree
2845:AA tree
2563:(KIT).
2345:7932878
2337:0895444
2260:4145204
1466:merged.
1273:level.
1269:at the
1194:to the
1156:HP 3000
1135:called
833:println
156:History
106:analogy
2933:Graphs
2894:R-tree
2835:B-tree
2789:Linked
2746:Arrays
2555:]
2514:]
2493:
2379:
2343:
2335:
2258:
2197:
2172:
2162:
2001:
1920:
1840:
1830:
1818:]
1623:
1263:COP400
1259:NC4016
1250:, the
1243:, the
1224:, and
1114:HP-42S
1083:PDP-11
1057:-type
994:: the
821:System
728:String
707:String
689:String
677:static
674:public
656:import
644:Vector
507:'c
504:'b
501:'a
453:Python
429:return
369:return
208:patent
132:bottom
104:is an
71:is an
2827:Trees
2700:Queue
2695:Stack
2643:Types
2568:(PDF)
2557:(PDF)
2551:[
2523:(PDF)
2516:(PDF)
2510:[
2449:from
2410:(PDF)
2341:S2CID
2290:(PDF)
2283:(PDF)
2058:(PDF)
2047:(PDF)
1999:S2CID
1849:(PDF)
1820:(PDF)
1814:[
1745:(PDF)
1734:(PDF)
1568:queue
1554:Notes
1531:Queue
1348:datum
1267:Forth
1256:Novix
1248:MuP21
1206:(for
1165:The
1122:HP-48
1087:68000
1053:Many
1040:after
869:stack
854:stack
839:stack
800:stack
779:stack
758:stack
737:stack
722:Stack
713:stack
701:Stack
665:class
638:Stack
625:stack
585:stack
555:stack
540:stack
492:stack
457:Forth
294:array
284:Array
272:or a
270:array
234:]
176:stack
121:datum
102:stack
69:stack
2916:Trie
2872:Heap
2690:List
2491:ISBN
2463:NIST
2256:SSRN
2252:2020
2195:ISBN
2170:LCCN
2160:ISBN
1918:ISBN
1838:ISSN
1828:ISBN
1621:ISBN
1572:FIFO
1457:The
1363:are
1336:and
1186:and
1146:and
1109:The
1095:RISC
1079:code
1071:6502
1069:and
1055:CISC
1009:and
982:Swap
972:Peek
939:pull
928:push
848:());
845:peek
806:push
785:push
764:push
743:push
731:>
725:<
710:>
704:<
692:args
683:main
680:void
649:Java
619:and
579:push
573:>
552:>
531:>
498:list
489:setf
483:>
476:>
472:>
451:and
445:LISP
441:Perl
365:else
340:else
322:push
320:The
315:size
212:IEEE
192:and
117:LIFO
98:peek
84:Push
67:, a
55:and
53:push
2724:Set
2422:doi
2387:doi
2325:doi
1989:doi
1791:).)
1682:doi
1212:x87
1181:bus
1167:x87
1067:Z80
1063:x86
1059:CPU
1003:= 3
984:or
976:top
937:or
935:pop
878:();
875:pop
863:();
860:pop
827:out
734:();
719:new
629:API
597:NEW
537:pop
351:top
347:pop
326:top
298:top
196:of
182:'s
128:top
90:Pop
63:In
57:pop
2981::
2538:.)
2479:.
2461:.
2455:.
2418:26
2416:.
2412:.
2385:.
2373:14
2371:.
2363:;
2339:.
2333:MR
2331:.
2319:.
2311:;
2307:;
2254:.
2250:.
2246:.
2227:.
2168:.
2155:,
2092:.
1997:.
1983:.
1977:.
1969:;
1943:;
1926:.
1904:;
1875:;
1844:.
1836:.
1796:^
1705:;
1678:20
1676:.
1670:.
1662:;
1609:;
1605:;
1601:;
1590:^
1383:.
1220:,
1162:.
1139:.
1065:,
1020:A
933:A
926:A
815:);
794:);
773:);
752:);
510:))
470:("
447:,
443:,
431:r
425:if
371:r
361:if
336:if
280:.
232:de
184:Z4
152:.
145:.
2628:e
2621:t
2614:v
2577:.
2532:.
2465:.
2432:.
2430:.
2424::
2395:.
2393:.
2389::
2349:.
2347:.
2327::
2321:2
2262:.
2209:.
2176:.
2132:.
2107:.
2067:.
2005:.
1991::
1985:3
1953:1
1890:.
1858:.
1754:.
1690:.
1684::
1647:.
1629:.
1574:.
1001:n
996:n
887:}
884:}
872:.
857:.
842:.
836:(
830:.
824:.
809:(
803:.
788:(
782:.
767:(
761:.
746:(
740:.
716:=
698:{
695:)
686:(
671:{
662:;
606:)
603:C
600:B
594:(
588:)
576:(
570:)
567:C
564:B
561:(
549:A
543:)
534:(
528:)
525:C
522:B
519:A
516:(
495:(
486:(
34:.
20:)
Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.
