b'\n_START_ARTICLE_\nIBM 1130\n_START_PARAGRAPH_\nEl Sistema de Computaci\xc3\xb3n IBM 1130 fue introducido en 1965.\xe2\x80\x8b Era el equipo menos caro de IBM, y apuntaba al mercado de bajo costo de computaci\xc3\xb3n t\xc3\xa9cnica intensiva, como la ingenier\xc3\xada y la educaci\xc3\xb3n. El IBM 1800 fue una variante de control de proceso del 1130 con dos instrucciones agregadas (CMP y DCM) y capacidades de entrada/salida extra.\n_START_SECTION_\nDescripci\xc3\xb3n\n_START_PARAGRAPH_\nEl 1130 se volvi\xc3\xb3 muy popular, y junto con los clones no-IBM fueron el primer contacto con la "computaci\xc3\xb3n personal" para muchas personas. Su relaci\xc3\xb3n precio/prestaciones fue buena y, notablemente, inclu\xc3\xada un dispositivo de almacenamiento en disco removible, el cual no era caro, junto a un sistema operativo en disco sencillo y confiable, que soportaba varios lenguajes de alto nivel. El bajo precio y unas prestaciones bien balanceadas hicieron que se transforme en un "taller abierto" para el desarrollo de programas, disponible para un gran n\xc3\xbamero de usuarios por primera vez.\n_START_SECTION_\nProcesador y memoria\n_START_PARAGRAPH_\nEl IBM 1130 usaba m\xc3\xb3dulos electr\xc3\xb3nicos del System/360 llamados Tecnolog\xc3\xada de Estado S\xc3\xb3lido (SLT, por sus siglas en ingl\xc3\xa9s) y ten\xc3\xadan una arquitectura binaria de 16 bit, no muy diferente a las minicomputadoras posteriores, como la PDP-11 o la Data General Nova. El espacio de direccionamiento era de 15 bits, limitando la memoria del 1130 a 32K palabras de 16 bit (64 Kbytes). Ten\xc3\xada capacidad de direccionamiento directo e indirecto.\n_START_SECTION_\nSoftware\n_START_PARAGRAPH_\nMuchos programas fueron hechos en Fortran. El compilador Fortran del 1130 pod\xc3\xada correr en una m\xc3\xa1quina con solo 4.096 palabras de memoria principal. Esto es 8 kilobytes, menos que el espacio m\xc3\xadnimo de direccionamiento de archivos del sistema de archivos de algunos PC. Para maximizar la velocidad y conservar espacio, el sistema operativo y los compiladores estaban escritos enteramente en lenguaje ensamblador, y las t\xc3\xa9cnicas empleadas son poco vistas hoy d\xc3\xada, incluyendo la estrecha integraci\xc3\xb3n de c\xc3\xb3digos y datos y el c\xc3\xb3digo auto-modificable. Para permitir el uso de programas que eran muy grandes para caber en la memoria principal, la implementaci\xc3\xb3n del lenguaje Fortran permit\xc3\xada que cualquier subrutina sea designada como "LOCAL", es decir, era cargada a la memoria al ser llamada. El uso de c\xc3\xb3digo residente en disco requer\xc3\xada que el c\xc3\xb3digo ejecutable, por ejemplo una subrutina, sea "cargado" (le\xc3\xaddo) del disco a la memoria (si no estaba ya presente en la memoria) cuando la subrutina era "llamada" (invocada). El compilador estaba disponible en una versi\xc3\xb3n residente en disco, as\xc3\xad como tambi\xc3\xa9n en una cinta perforada de 8 canales o en tarjeta perforada_NEWLINE_Otros lenguajes de programaci\xc3\xb3n estaban disponibles en el 1130, incluyendo: APL,\xe2\x80\x8b BASIC, COBOL, FORTH, PL/I y RPG. La Eastern Michigan University desarroll\xc3\xb3 un compilador Fortran IV para el 1130, conocido como Fortran-EMU, que correg\xc3\xada un detalle del compilador de IBM: la falta de un tipo de datos L\xc3\x93GICO.\n_START_SECTION_\nPerif\xc3\xa9ricos\n_START_PARAGRAPH_\nEl sistema 1130 b\xc3\xa1sico incorporaba una unidad de disco IBM 2310. \xc3\x89sta le\xc3\xada los cartuchos 2315 (del tama\xc3\xb1o de una caja de pizza) de un solo plato que almacenaban 512 K palabras o 1 Mb (menos que un diskette de 3,5" HD). Los discos se usaban para almacenar el sistema operativo, el c\xc3\xb3digo objeto y los datos, pero no el c\xc3\xb3digo fuente. Este \xc3\xbaltimo se manten\xc3\xada en tarjetas perforadas. El sistema operativo en disco era llamado DMS o DM2 (por Disk Monitor System, Release 2)._NEWLINE_Otros perif\xc3\xa9ricos disponibles inclu\xc3\xadan las impresoras de l\xc3\xadneas IBM 1132 y IBM 1403, la lectora/perforadora de tarjetas IBM 1442, la unidad de disco IBM 2311, el monitor de gr\xc3\xa1ficos IBM 2250 y el trazador gr\xc3\xa1fico (pl\xc3\xb3ter) de tambor IBM 1627. El pl\xc3\xb3ter era muy usado en trabajos de ingenier\xc3\xada. La consola usaba un mecanismo IBM Selectric, lo cual significaba que pod\xc3\xada cambiarse el tipo de letra reemplazando el elemento impresor, el que consist\xc3\xada en una bola hueca del tama\xc3\xb1o de una pelota de golf. Hab\xc3\xada un tipo especial disponible para el APL, un poderoso lenguaje de programaci\xc3\xb3n orientado al c\xc3\xa1lculo de matrices que usaba una notaci\xc3\xb3n simb\xc3\xb3lica especial._NEWLINE_El IBM 1130 MTCA, por Multiple Terminal Control Adapter (Adaptador de Terminal de Control M\xc3\xbaltiple), fue anunciado al final de la vida de los producto 1130; permit\xc3\xada conectar hasta 2.741 terminales a un IBM 1130, para usar con APL._NEWLINE_A partir de 1968, la unidad de cinta magn\xc3\xa9tica IBM 2415 estaba disponible como RPQ (a precio especial).\xe2\x80\x8b_NEWLINE_Un 1130 est\xc3\xa1ndar ten\xc3\xada un ciclo de memoria de 3,6 microsegundos, y un modelo m\xc3\xa1s caro estaba equipado con una memoria con un ciclo de 2,2 \xc2\xb5s (se pod\xc3\xada usar este \xc3\xbaltimo con una impresora 1403 conectada a trav\xc3\xa9s de un multiplexor 1133). Para aprovechar mejor la gama baja del mercado, IBM introdujo el 1130 Modelo 4, con un ciclo de 5,6 \xc2\xb5s, a precio m\xc3\xa1s bajo, por supuesto. La impresora 1132 del Modelo 4 se redujo tambi\xc3\xa9n, pero la CPU m\xc3\xa1s lenta no pod\xc3\xada seguir su ritmo (La 1132 usaba la CPU para determinar que rueda de impresi\xc3\xb3n deb\xc3\xada dispararse mientras giraba, una funci\xc3\xb3n que consum\xc3\xada mucha capacidad de c\xc3\xa1lculo). Una lectura cuidadosa del manual del hardware del 1130 descubr\xc3\xada que cuando el nivel (1) de interrupci\xc3\xb3n de la impresora o la interrupci\xc3\xb3n (0) de la columna de la 1442 estaban activados, el 1130 Modelo 4 funcionaba a la velocidad m\xc3\xa1s r\xc3\xa1pida de 3,6 microsegundos por ciclo. Algunos usuarios del Modelo 4 escrib\xc3\xadan un falso controlador de impresora que activaba el nivel de interrupci\xc3\xb3n 1 y lo dejaba as\xc3\xad mientras duraba la parte de c\xc3\xa1lculos intensivos de su aplicaci\xc3\xb3n. No pod\xc3\xada haber operaciones de entrada/salida mientras esto suced\xc3\xada debido a que el 1442 usaba el nivel de interrupci\xc3\xb3n 4 para marcar el fin de la tarjeta. El nivel 0 era el nivel de interrupci\xc3\xb3n m\xc3\xa1s alto, y el nivel 5 era el m\xc3\xa1s bajo.\n_START_SECTION_\nDescripci\xc3\xb3n general del conjunto de instrucciones\n_START_PARAGRAPH_\nRegistros Principales:_NEWLINE_IAR = Registro de Direcci\xc3\xb3n de la Instrucci\xc3\xb3n_NEWLINE_ACC = Acumulador_NEWLINE_EXT = Extensi\xc3\xb3n de Registro_NEWLINE_XRx = \xc3\x8dndice de Registro x = 1,2,3_NEWLINE__NEWLINE_Conjunto de instrucciones nemot\xc3\xa9cnicas del 1130:_NEWLINE_LD   = Carga ACC                  STO  = Almacena ACC_NEWLINE_LDD  = Doble carga (ACC y EXT)    STD  = Doble almacenamiento (ACC y EXT)_NEWLINE_LDX  = \xc3\x8dndice de carga            STX  = \xc3\x8dndice de Almacenamiento_NEWLINE_LDS  = Estado de carga            STS  = Estado de almacenamiento_NEWLINE_A    = Suma ACC                   AD   = Suma doble_NEWLINE_S    = Resta ACC                  SD   = Resta Double_NEWLINE_M    = Multiplica                 D    = Divide_NEWLINE_AND  = Y booleano                 OR   = O booleano_NEWLINE_XOR  = O eXclusivo booleano_NEWLINE_SLA  = Despl. ACC a la izquierda  SLT  = Despl. ACC y EXT a la izquierda_NEWLINE_SLCA = Despl. Izq. y cuenta ACC   SLC  = Despl. Izq. y cuenta ACC y EXT_NEWLINE_SRA  = Despl. ACC a la derecha    SRT  = Despl. ACC & EXT a la derecha_NEWLINE_RTE  = Rota ACC & EXT derecha     XCH  = Intercambio ACC y EXT_NEWLINE_MDM  = Modifica Memoria_NEWLINE_B    = Bifurcaci\xc3\xb3n_NEWLINE_BSC  = Bifurcaci\xc3\xb3n o Salto en condici\xc3\xb3n (Depende del Modificador)_NEWLINE_       i.e. BP BNP BN BNN BZ BNZ BC BO BOD_NEWLINE_BSI  = Bifurcaci\xc3\xb3n y almacena IAR_NEWLINE_MDX  = Modifica \xc3\x8dndice y Salta_NEWLINE_WAIT = Parar                      NOP  = No Operaci\xc3\xb3n_NEWLINE_XIO  = Ejecuta E/S_NEWLINE__NEWLINE_Instrucciones adicionales del 1800:_NEWLINE_CMP  = Compara ACC                DCM  = Comparaci\xc3\xb3n Doble ACC y EXT_NEWLINE__NEWLINE_Formato de instrucci\xc3\xb3n corta (una palabra de 16 bit):_NEWLINE_                       1_NEWLINE_Bits    0...45678......5_NEWLINE_        OP---FTTDisp----_NEWLINE__NEWLINE_OP    es Operaci\xc3\xb3n_NEWLINE_F     es formato 0 = Short_NEWLINE_TT    es Etiqueta_NEWLINE_Disp  es Desplazamiento_NEWLINE__NEWLINE_Formato de instrucci\xc3\xb3n largo (dos palabras de 16 bit):_NEWLINE_                       1               1_NEWLINE_Bits    0...456789.....50..............5_NEWLINE_        OP---FTTIMod----Direcci\xc3\xb3n-------_NEWLINE__NEWLINE_OP    es Operaci\xc3\xb3n_NEWLINE_F     es formato 1 = Largo_NEWLINE_TT    es Etiqueta_NEWLINE_I     es bit Indirecto_NEWLINE_Mod   es Modificador_NEWLINE__NEWLINE_C\xc3\xa1lculo de Direcci\xc3\xb3n Efectiva (EA):_NEWLINE_          F = 0            | F = 1, I = 0     | F = 1, I = 1_NEWLINE_          Direcci\xc3\xb3n Directa| Direcci\xc3\xb3n Directa| Direcci\xc3\xb3n Indirecta_NEWLINE_-------------------------------------------------------------------_NEWLINE_TT = 00 | EA = Despl + IAR | EA = Suma        | EA = C/Suma_NEWLINE_TT = 01 | EA = Despl + XR1 | EA = Suma + XR1  | EA = C/Suma + XR1_NEWLINE_TT = 10 | EA = Despl + XR2 | EA = Suma + XR2  | EA = C/Suma + XR2_NEWLINE_TT = 11 | EA = Despl + XR3 | EA = Suma + XR2  | EA = C/Suma + XR3_NEWLINE_-------------------------------------------------------------------_NEWLINE_    Desp = Contiene el campo de desplazamiento_NEWLINE_    Suma = Contiene la direcci\xc3\xb3n del campo de la instrucci\xc3\xb3n_NEWLINE_       C = Contiene la locaclizaci\xc3\xb3n espec\xc3\xadfica haciendo Suma o Suma + XR\n_START_SECTION_\nEjemplos de Programas\n_START_PARAGRAPH_\nLos ejemplos pueden ejecutarse en un emulador de IBM 1130 disponible en IBM 1130.org (en ingl\xc3\xa9s).\n_START_SECTION_\nEjemplo de programa en Ensamblador\n_START_PARAGRAPH_\nEl siguiente listado muestra el contenido de un conjunto de tarjetas perforadas que compilan y ejecutan un programa en ensamblador que lee las tarjetas perforadas y las imprime en la impresora en l\xc3\xadnea._NEWLINE__NEWLINE_El c\xc3\xb3digo siguiente Copyright (c) 2006 Kym Farnik. C\xc3\xb3digo publicado bajo la licencia MIT. Ver: http://www.opensource.org/licenses/mit-license.php_NEWLINE_ // JOB _NEWLINE_ // ASM_NEWLINE_ *LIST_NEWLINE_                     * LCARD.ASM - LIST A DECK OF CARDS TO LINE PRINTER_NEWLINE_                     *_NEWLINE_                     * COPYRIGHT (C) 2006 KYM FARNIK. _NEWLINE_                     * CODE PUBLISHED UNDER MIT LICENSE. _NEWLINE_                     *_NEWLINE_                     * PROGRAM_NEWLINE_                     *    NEW PAGE ON PRINTER_NEWLINE_                     * A  READ A CARD_NEWLINE_                     *    CONVERT FORMAT_NEWLINE_                     *    PRINT A LINE ON PRINTER_NEWLINE_                     *    GOTO A_NEWLINE_                     *_NEWLINE_                     START LIBF    PRNT1    GOTO NEW PAGE ON 1132_NEWLINE_                           DC      /3100    PRINTER CHANNEL 1-NEW PAGE_NEWLINE_                     *_NEWLINE_                     NEXTC LIBF    CARD0    READ FROM 1442 CARD READER_NEWLINE_                           DC      /1000    CONTROL TO READ_NEWLINE_                           DC      CBUFF    STORE 80 COLUMNS_NEWLINE_                     CINP  LIBF    CARD0_NEWLINE_                           DC      0_NEWLINE_                           B       CINP     LOOP UNTIL CARD IS READ_NEWLINE_                     *_NEWLINE_                           LIBF    ZIPCO    CONVERT CARD TO PRINTER_NEWLINE_                           DC      /1100    UNPACKED IN, PACKED OUT_NEWLINE_                           DC      CBUFF+1  INPUT BUFFER_NEWLINE_                           DC      PBUFF+1  OUTPUT BUFFER_NEWLINE_                           DC      80       CHARACTER COUNT_NEWLINE_                           CALL    HLEBC    HOLLERITH TO EBCDIC_NEWLINE_                     *_NEWLINE_                           LIBF    PRNT1    PRINT 80 CHARACTERS_NEWLINE_                           DC      /2000    CONTROL CODE TO PRINT_NEWLINE_                           DC      PBUFF    PRINT BUFFER_NEWLINE_                           DC      PERR     PRINT ERROR_NEWLINE_                     POUT  LIBF    PRNT1    CHECK FOR PRINT COMPLETE_NEWLINE_                           DC      0_NEWLINE_                           B       POUT     LOOP UNTIL COMPLETE_NEWLINE_                     *_NEWLINE_                           B       NEXTC    READ NEXT CARD_NEWLINE_                     *_NEWLINE_                     * DATA_NEWLINE_                     *_NEWLINE_                     CBUFF DC      80       80 COLUMNS PER CARD_NEWLINE_                           BSS     80_NEWLINE_                     *_NEWLINE_                     PBUFF DC      40       40 WORDS 80 CHARACTERS_NEWLINE_                           BSS     40_NEWLINE_                     *_NEWLINE_                     PERR  DC      0_NEWLINE_                           B    I  PERR     THIS RETURNS TO THE_NEWLINE_                     *                       PRINTER ERROR HANDLER_NEWLINE_                     *                       WHICH WILL TERMINATE THE PROGRAM_NEWLINE_                     *_NEWLINE_                           END     START    PROGRAM ENTRY POINT_NEWLINE_ // XEQ_NEWLINE_ TEST DATA 1_NEWLINE_ HELLO WORLD_NEWLINE_ TEST DATA 2\n_START_SECTION_\nEjemplo de programa en Fortran IV\n_START_PARAGRAPH_\nEl siguiente listado muestra el contenido de un conjunto de tarjetas perforadas que compilan y ejecutan un programa en Fortran y una subrutina en Fortran para el IBM 1130 corriendo el DM2._NEWLINE__NEWLINE_El c\xc3\xb3digo siguiente Copyright (c) 2006 Kym Farnik. C\xc3\xb3digo publicado bajo la licencia MIT. Ver: http://www.opensource.org/licenses/mit-license.php_NEWLINE_ // JOB _NEWLINE_ // FOR_NEWLINE_ *LIST SOURCE PROGRAM_NEWLINE_ *ONE WORD INTEGERS_NEWLINE_ C-------------------------------------------------------   _NEWLINE_ C COMPUTE THE CRITICAL VALUES FOR A QUADRATIC EQN_NEWLINE_ C 0=A*X**2+B*X+C_NEWLINE_ C RETURNS DISCRIMINANT, ROOTS, VERTEX, FOCAL LENGTH, FOCAL POINT_NEWLINE_ C X1 AND X2 ARE THE ROOTS_NEWLINE_ C-------------------------------------------------------   _NEWLINE_       SUBROUTINE QUADR(A,B,C,DISCR,X1,X2,VX,VY,FL,FPY)_NEWLINE_       REAL A,B,C,DISCR,X1,X2,VX,VY,FL,FPY_NEWLINE__NEWLINE_ C DISCRIMINANT, VERTEX, FOCAL LENGTH, FOCAL POINT Y_NEWLINE_       DISCR = B**2.0 - 4.0*A*C_NEWLINE_       VX = -B / (2.0*A)_NEWLINE_       VY = A*VX**2.0 + B*VX + C_NEWLINE_       FL = 1.0 / (A * 4.0)_NEWLINE_       FPY = VY + FL_NEWLINE_       FL = ABS(FL)_NEWLINE__NEWLINE_ C COMPUTE THE ROOTS BASED ON THE DISCRIMINANT_NEWLINE_       IF(DISCR) 110,120,130_NEWLINE__NEWLINE_ C -VE DISCRIMINANT, TWO COMPLEX ROOTS, REAL=X1, IMG=+/-X2_NEWLINE_ 110   X1 = -B / (2.0*A)_NEWLINE_       X2 = SQRT(-DISCR) / (2.0*A)_NEWLINE_       RETURN_NEWLINE_       _NEWLINE_ C ZERO DISCRIMINANT, ONE REAL ROOT_NEWLINE_ 120   X1 = -B / (2.0*A)_NEWLINE_       X2 = X1_NEWLINE_       RETURN _NEWLINE__NEWLINE_ C +VE DISCRIMINANT, TWO REAL ROOTS_NEWLINE_ 130   X1 = (-B + SQRT(DISCR)) / (2.0*A)_NEWLINE_       X2 = (-B - SQRT(DISCR)) / (2.0*A)_NEWLINE_       RETURN_NEWLINE_ C_NEWLINE_ C NEXT STORE SUBROUTINE ON DISK USING DUP_NEWLINE_       END_NEWLINE_ // DUP_NEWLINE_ *DELETE             QUADR_NEWLINE_ *STORE      WS  UA  QUADR_NEWLINE_ // JOB_NEWLINE_ // FOR_NEWLINE_ *LIST SOURCE PROGRAM   _NEWLINE_ *IOCS(CARD,1132 PRINTER)   _NEWLINE_ *ONE WORD INTEGERS   _NEWLINE_ C-------------------------------------------------------   _NEWLINE_ C PROCESS DATA CARDS WITH A,B,C_NEWLINE_ C UNTIL A=0_NEWLINE_ C-------------------------------------------------------   _NEWLINE__NEWLINE_       DATA ICARD,IPRT /2,3/_NEWLINE_       REAL A,B,C_NEWLINE_       REAL DISCR,XR1,XR2,VX,VY,FL,FPY_NEWLINE__NEWLINE_       WRITE(IPRT,901)_NEWLINE_ 901   FORMAT(\' ------------------------------------------------------\')_NEWLINE__NEWLINE_ C READ A B C, IF A=0 THEN EXIT_NEWLINE_ 100   READ(ICARD,801)A,B,C_NEWLINE_ 801   FORMAT(3F8.3)_NEWLINE__NEWLINE_ C     EXIT WHEN A IS ZERO_NEWLINE_       IF (A) 110,9000,110_NEWLINE__NEWLINE_ C PRINT A B C _NEWLINE_ 110   WRITE(IPRT,902)A,B,C_NEWLINE_ 902   FORMAT(\' QUADRATIC A=\',F8.3,\' B=\',F8.3,\' C=\',F8.3)_NEWLINE__NEWLINE_ C COMPUTE AND PRINT THE CRITICAL VALUES_NEWLINE_       CALL QUADR(A,B,C,DISCR,XR1,XR2,VX,VY,FL,FPY)_NEWLINE_       WRITE(IPRT,903) DISCR_NEWLINE_ 903   FORMAT(\' DISCRIMINANT=\',F9.4)_NEWLINE_       WRITE(IPRT,904) VX,VY_NEWLINE_ 904   FORMAT(\' VERTEX X=\',F9.4,\'  Y=\',F9.4)_NEWLINE_       WRITE(IPRT,905) FL_NEWLINE_ 905   FORMAT(\' FOCAL LENGTH=\',F9.4)_NEWLINE_       WRITE(IPRT,906) VX,FPY_NEWLINE_ 906   FORMAT(\' FOCAL POINT X=\',F9.4,\'  Y=\'F9.4)_NEWLINE__NEWLINE_       IF (DISCR) 120,130,140_NEWLINE__NEWLINE_ C -VE DISCRIMINANT, TWO COMPLEX ROOTS_NEWLINE_ 120   WRITE(IPRT,913) XR1, XR2_NEWLINE_ 913   FORMAT(\' COMPLEX ROOTS =(\',F9.4,\'  +/-\',F9.4,\'I)\')_NEWLINE_       GO TO 200_NEWLINE_       _NEWLINE_ C ZERO DISCRIMINANT, ONE REAL ROOT_NEWLINE_ 130   WRITE(IPRT,912) XR1_NEWLINE_ 912   FORMAT(\' ROOT  X =\',F9.4)_NEWLINE_       GO TO 200_NEWLINE__NEWLINE_ C +VE DISCRIMINANT, TWO REAL ROOTS_NEWLINE_ 140   WRITE(IPRT,911) XR1, XR2_NEWLINE_ 911   FORMAT(\' ROOTS X1=\',F9.4,\'   X2=\',F9.4)_NEWLINE_ C --- GO TO 200_NEWLINE__NEWLINE_ C END OF QUAD_NEWLINE_ 200   WRITE(IPRT,901)_NEWLINE_       GO TO 100_NEWLINE__NEWLINE_ C END OF PROGRAM_NEWLINE_ C DATA FOLLOWS XEQ CARD_NEWLINE_ 9000  CALL EXIT   _NEWLINE_       END   _NEWLINE_ // XEQ_NEWLINE_ +001.000+000.000+000.000_NEWLINE_ +001.000+002.000+003.000_NEWLINE_ +002.000+002.000+000.000_NEWLINE_ +002.000+000.000-004.000_NEWLINE_ +000.500+000.000-004.000_NEWLINE_ +000.250+002.000-002.000_NEWLINE_ -004.000+000.000-004.000_NEWLINE_ +002.730-007.200-003.750_NEWLINE_ +000.000+000.000+000.000\n_START_SECTION_\nEjemplo de sesi\xc3\xb3n en APL \\ 1130\n_START_PARAGRAPH_\nLa siguiente imagen muestra una sesi\xc3\xb3n APL \\ 1130 sencilla. Esta sesi\xc3\xb3n fue realizada v\xc3\xada el simulador 1130 disponible de IBM 1130.org_NEWLINE__NEWLINE_Esta imagen muestra el ingreso a la sesi\xc3\xb3n, la adici\xc3\xb3n de enteros del 1 al 100, la generaci\xc3\xb3n de una tabala de adiciones para los entereos 1..5 y la salida de la sesi\xc3\xb3n.'