X-Git-Url: https://pd.if.org/git/?p=lice;a=blobdiff_plain;f=tests%2Fargs.c;fp=tests%2Fargs.c;h=da09247abc53b1eb60d773e698895c2f8b041f26;hp=0000000000000000000000000000000000000000;hb=bb650f4a52a456c1aa0a34508d6f3dcce58291b6;hpb=686688990cde8ecd8d9423fde7f88b6ac6ac8a40 diff --git a/tests/args.c b/tests/args.c new file mode 100644 index 0000000..da09247 --- /dev/null +++ b/tests/args.c @@ -0,0 +1,713 @@ +// function arguments + +void test_int(int value1 , int value2 , int value3 , int value4 , + int value5 , int value6 , int value7 , int value8 , + int value9 , int value10 , int value11 , int value12 , + int value13 , int value14 , int value15 , int value16 , + int value17 , int value18 , int value19 , int value20 , + int value21 , int value22 , int value23 , int value24 , + int value25 , int value26 , int value27 , int value28 , + int value29 , int value30 , int value31 , int value32 , + int value33 , int value34 , int value35 , int value36 , + int value37 , int value38 , int value39 , int value40 , + int value41 , int value42 , int value43 , int value44 , + int value45 , int value46 , int value47 , int value48 , + int value49 , int value50 , int value51 , int value52 , + int value53 , int value54 , int value55 , int value56 , + int value57 , int value58 , int value59 , int value60 , + int value61 , int value62 , int value63 , int value64 , + int value65 , int value66 , int value67 , int value68 , + int value69 , int value70 , int value71 , int value72 , + int value73 , int value74 , int value75 , int value76 , + int value77 , int value78 , int value79 , int value80 , + int value81 , int value82 , int value83 , int value84 , + int value85 , int value86 , int value87 , int value88 , + int value89 , int value90 , int value91 , int value92 , + int value93 , int value94 , int value95 , int value96 , + int value97 , int value98 , int value99 , int value100, + int value101, int value102, int value103, int value104, + int value105, int value106, int value107, int value108, + int value109, int value110, int value111, int value112, + int value113, int value114, int value115, int value116, + int value117, int value118, int value119, int value120, + int value121, int value122, int value123, int value124, + int value125, int value126, int value127) { + expecti(value1, 1); + expecti(value2, 2); + expecti(value3, 3); + expecti(value4, 4); + expecti(value5, 5); + expecti(value6, 6); + expecti(value7, 7); + expecti(value8, 8); + expecti(value9, 9); + expecti(value10, 10); + expecti(value11, 11); + expecti(value12, 12); + expecti(value13, 13); + expecti(value14, 14); + expecti(value15, 15); + expecti(value16, 16); + expecti(value17, 17); + expecti(value18, 18); + expecti(value19, 19); + expecti(value20, 20); + expecti(value21, 21); + expecti(value22, 22); + expecti(value23, 23); + expecti(value24, 24); + expecti(value25, 25); + expecti(value26, 26); + expecti(value27, 27); + expecti(value28, 28); + expecti(value29, 29); + expecti(value30, 30); + expecti(value31, 31); + expecti(value32, 32); + expecti(value33, 33); + expecti(value34, 34); + expecti(value35, 35); + expecti(value36, 36); + expecti(value37, 37); + expecti(value38, 38); + expecti(value39, 39); + expecti(value40, 40); + expecti(value41, 41); + expecti(value42, 42); + expecti(value43, 43); + expecti(value44, 44); + expecti(value45, 45); + expecti(value46, 46); + expecti(value47, 47); + expecti(value48, 48); + expecti(value49, 49); + expecti(value50, 50); + expecti(value51, 51); + expecti(value52, 52); + expecti(value53, 53); + expecti(value54, 54); + expecti(value55, 55); + expecti(value56, 56); + expecti(value57, 57); + expecti(value58, 58); + expecti(value59, 59); + expecti(value60, 60); + expecti(value61, 61); + expecti(value62, 62); + expecti(value63, 63); + expecti(value64, 64); + expecti(value65, 65); + expecti(value66, 66); + expecti(value67, 67); + expecti(value68, 68); + expecti(value69, 69); + expecti(value70, 70); + expecti(value71, 71); + expecti(value72, 72); + expecti(value73, 73); + expecti(value74, 74); + expecti(value75, 75); + expecti(value76, 76); + expecti(value77, 77); + expecti(value78, 78); + expecti(value79, 79); + expecti(value80, 80); + expecti(value81, 81); + expecti(value82, 82); + expecti(value83, 83); + expecti(value84, 84); + expecti(value85, 85); + expecti(value86, 86); + expecti(value87, 87); + expecti(value88, 88); + expecti(value89, 89); + expecti(value90, 90); + expecti(value91, 91); + expecti(value92, 92); + expecti(value93, 93); + expecti(value94, 94); + expecti(value95, 95); + expecti(value96, 96); + expecti(value97, 97); + expecti(value98, 98); + expecti(value99, 99); + expecti(value100, 100); + expecti(value101, 101); + expecti(value102, 102); + expecti(value103, 103); + expecti(value104, 104); + expecti(value105, 105); + expecti(value106, 106); + expecti(value107, 107); + expecti(value108, 108); + expecti(value109, 109); + expecti(value110, 110); + expecti(value111, 111); + expecti(value112, 112); + expecti(value113, 113); + expecti(value114, 114); + expecti(value115, 115); + expecti(value116, 116); + expecti(value117, 117); + expecti(value118, 118); + expecti(value119, 119); + expecti(value120, 120); + expecti(value121, 121); + expecti(value122, 122); + expecti(value123, 123); + expecti(value124, 124); + expecti(value125, 125); + expecti(value126, 126); + expecti(value127, 127); +} +void test_short(short value1 , short value2 , short value3 , short value4 , + short value5 , short value6 , short value7 , short value8 , + short value9 , short value10 , short value11 , short value12 , + short value13 , short value14 , short value15 , short value16 , + short value17 , short value18 , short value19 , short value20 , + short value21 , short value22 , short value23 , short value24 , + short value25 , short value26 , short value27 , short value28 , + short value29 , short value30 , short value31 , short value32 , + short value33 , short value34 , short value35 , short value36 , + short value37 , short value38 , short value39 , short value40 , + short value41 , short value42 , short value43 , short value44 , + short value45 , short value46 , short value47 , short value48 , + short value49 , short value50 , short value51 , short value52 , + short value53 , short value54 , short value55 , short value56 , + short value57 , short value58 , short value59 , short value60 , + short value61 , short value62 , short value63 , short value64 , + short value65 , short value66 , short value67 , short value68 , + short value69 , short value70 , short value71 , short value72 , + short value73 , short value74 , short value75 , short value76 , + short value77 , short value78 , short value79 , short value80 , + short value81 , short value82 , short value83 , short value84 , + short value85 , short value86 , short value87 , short value88 , + short value89 , short value90 , short value91 , short value92 , + short value93 , short value94 , short value95 , short value96 , + short value97 , short value98 , short value99 , short value100, + short value101, short value102, short value103, short value104, + short value105, short value106, short value107, short value108, + short value109, short value110, short value111, short value112, + short value113, short value114, short value115, short value116, + short value117, short value118, short value119, short value120, + short value121, short value122, short value123, short value124, + short value125, short value126, short value127) { + expects(value1, 1); + expects(value2, 2); + expects(value3, 3); + expects(value4, 4); + expects(value5, 5); + expects(value6, 6); + expects(value7, 7); + expects(value8, 8); + expects(value9, 9); + expects(value10, 10); + expects(value11, 11); + expects(value12, 12); + expects(value13, 13); + expects(value14, 14); + expects(value15, 15); + expects(value16, 16); + expects(value17, 17); + expects(value18, 18); + expects(value19, 19); + expects(value20, 20); + expects(value21, 21); + expects(value22, 22); + expects(value23, 23); + expects(value24, 24); + expects(value25, 25); + expects(value26, 26); + expects(value27, 27); + expects(value28, 28); + expects(value29, 29); + expects(value30, 30); + expects(value31, 31); + expects(value32, 32); + expects(value33, 33); + expects(value34, 34); + expects(value35, 35); + expects(value36, 36); + expects(value37, 37); + expects(value38, 38); + expects(value39, 39); + expects(value40, 40); + expects(value41, 41); + expects(value42, 42); + expects(value43, 43); + expects(value44, 44); + expects(value45, 45); + expects(value46, 46); + expects(value47, 47); + expects(value48, 48); + expects(value49, 49); + expects(value50, 50); + expects(value51, 51); + expects(value52, 52); + expects(value53, 53); + expects(value54, 54); + expects(value55, 55); + expects(value56, 56); + expects(value57, 57); + expects(value58, 58); + expects(value59, 59); + expects(value60, 60); + expects(value61, 61); + expects(value62, 62); + expects(value63, 63); + expects(value64, 64); + expects(value65, 65); + expects(value66, 66); + expects(value67, 67); + expects(value68, 68); + expects(value69, 69); + expects(value70, 70); + expects(value71, 71); + expects(value72, 72); + expects(value73, 73); + expects(value74, 74); + expects(value75, 75); + expects(value76, 76); + expects(value77, 77); + expects(value78, 78); + expects(value79, 79); + expects(value80, 80); + expects(value81, 81); + expects(value82, 82); + expects(value83, 83); + expects(value84, 84); + expects(value85, 85); + expects(value86, 86); + expects(value87, 87); + expects(value88, 88); + expects(value89, 89); + expects(value90, 90); + expects(value91, 91); + expects(value92, 92); + expects(value93, 93); + expects(value94, 94); + expects(value95, 95); + expects(value96, 96); + expects(value97, 97); + expects(value98, 98); + expects(value99, 99); + expects(value100, 100); + expects(value101, 101); + expects(value102, 102); + expects(value103, 103); + expects(value104, 104); + expects(value105, 105); + expects(value106, 106); + expects(value107, 107); + expects(value108, 108); + expects(value109, 109); + expects(value110, 110); + expects(value111, 111); + expects(value112, 112); + expects(value113, 113); + expects(value114, 114); + expects(value115, 115); + expects(value116, 116); + expects(value117, 117); + expects(value118, 118); + expects(value119, 119); + expects(value120, 120); + expects(value121, 121); + expects(value122, 122); + expects(value123, 123); + expects(value124, 124); + expects(value125, 125); + expects(value126, 126); + expects(value127, 127); +} +void test_long(long value1 , long value2 , long value3 , long value4 , + long value5 , long value6 , long value7 , long value8 , + long value9 , long value10 , long value11 , long value12 , + long value13 , long value14 , long value15 , long value16 , + long value17 , long value18 , long value19 , long value20 , + long value21 , long value22 , long value23 , long value24 , + long value25 , long value26 , long value27 , long value28 , + long value29 , long value30 , long value31 , long value32 , + long value33 , long value34 , long value35 , long value36 , + long value37 , long value38 , long value39 , long value40 , + long value41 , long value42 , long value43 , long value44 , + long value45 , long value46 , long value47 , long value48 , + long value49 , long value50 , long value51 , long value52 , + long value53 , long value54 , long value55 , long value56 , + long value57 , long value58 , long value59 , long value60 , + long value61 , long value62 , long value63 , long value64 , + long value65 , long value66 , long value67 , long value68 , + long value69 , long value70 , long value71 , long value72 , + long value73 , long value74 , long value75 , long value76 , + long value77 , long value78 , long value79 , long value80 , + long value81 , long value82 , long value83 , long value84 , + long value85 , long value86 , long value87 , long value88 , + long value89 , long value90 , long value91 , long value92 , + long value93 , long value94 , long value95 , long value96 , + long value97 , long value98 , long value99 , long value100, + long value101, long value102, long value103, long value104, + long value105, long value106, long value107, long value108, + long value109, long value110, long value111, long value112, + long value113, long value114, long value115, long value116, + long value117, long value118, long value119, long value120, + long value121, long value122, long value123, long value124, + long value125, long value126, long value127) { + expectl(value1, 1); + expectl(value2, 2); + expectl(value3, 3); + expectl(value4, 4); + expectl(value5, 5); + expectl(value6, 6); + expectl(value7, 7); + expectl(value8, 8); + expectl(value9, 9); + expectl(value10, 10); + expectl(value11, 11); + expectl(value12, 12); + expectl(value13, 13); + expectl(value14, 14); + expectl(value15, 15); + expectl(value16, 16); + expectl(value17, 17); + expectl(value18, 18); + expectl(value19, 19); + expectl(value20, 20); + expectl(value21, 21); + expectl(value22, 22); + expectl(value23, 23); + expectl(value24, 24); + expectl(value25, 25); + expectl(value26, 26); + expectl(value27, 27); + expectl(value28, 28); + expectl(value29, 29); + expectl(value30, 30); + expectl(value31, 31); + expectl(value32, 32); + expectl(value33, 33); + expectl(value34, 34); + expectl(value35, 35); + expectl(value36, 36); + expectl(value37, 37); + expectl(value38, 38); + expectl(value39, 39); + expectl(value40, 40); + expectl(value41, 41); + expectl(value42, 42); + expectl(value43, 43); + expectl(value44, 44); + expectl(value45, 45); + expectl(value46, 46); + expectl(value47, 47); + expectl(value48, 48); + expectl(value49, 49); + expectl(value50, 50); + expectl(value51, 51); + expectl(value52, 52); + expectl(value53, 53); + expectl(value54, 54); + expectl(value55, 55); + expectl(value56, 56); + expectl(value57, 57); + expectl(value58, 58); + expectl(value59, 59); + expectl(value60, 60); + expectl(value61, 61); + expectl(value62, 62); + expectl(value63, 63); + expectl(value64, 64); + expectl(value65, 65); + expectl(value66, 66); + expectl(value67, 67); + expectl(value68, 68); + expectl(value69, 69); + expectl(value70, 70); + expectl(value71, 71); + expectl(value72, 72); + expectl(value73, 73); + expectl(value74, 74); + expectl(value75, 75); + expectl(value76, 76); + expectl(value77, 77); + expectl(value78, 78); + expectl(value79, 79); + expectl(value80, 80); + expectl(value81, 81); + expectl(value82, 82); + expectl(value83, 83); + expectl(value84, 84); + expectl(value85, 85); + expectl(value86, 86); + expectl(value87, 87); + expectl(value88, 88); + expectl(value89, 89); + expectl(value90, 90); + expectl(value91, 91); + expectl(value92, 92); + expectl(value93, 93); + expectl(value94, 94); + expectl(value95, 95); + expectl(value96, 96); + expectl(value97, 97); + expectl(value98, 98); + expectl(value99, 99); + expectl(value100, 100); + expectl(value101, 101); + expectl(value102, 102); + expectl(value103, 103); + expectl(value104, 104); + expectl(value105, 105); + expectl(value106, 106); + expectl(value107, 107); + expectl(value108, 108); + expectl(value109, 109); + expectl(value110, 110); + expectl(value111, 111); + expectl(value112, 112); + expectl(value113, 113); + expectl(value114, 114); + expectl(value115, 115); + expectl(value116, 116); + expectl(value117, 117); + expectl(value118, 118); + expectl(value119, 119); + expectl(value120, 120); + expectl(value121, 121); + expectl(value122, 122); + expectl(value123, 123); + expectl(value124, 124); + expectl(value125, 125); + expectl(value126, 126); + expectl(value127, 127); +} +void test_mix(short value1 , short value2 , int value3 , short value4 , + long value5 , short value6 , short value7 , int value8 , + int value9 , short value10 , long value11 , short value12 , + long value13 , short value14 , long value15 , short value16 , + int value17 , int value18 , short value19 , short value20 , + long value21 , long value22 , int value23 , int value24 , + long value25 , long value26 , long value27 , short value28 , + short value29 , short value30 , long value31 , int value32 , + int value33 , int value34 , long value35 , int value36 , + short value37 , short value38 , short value39 , short value40 , + int value41 , int value42 , int value43 , long value44 , + long value45 , short value46 , long value47 , long value48 , + long value49 , int value50 , long value51 , short value52 , + short value53 , long value54 , long value55 , int value56 , + long value57 , long value58 , short value59 , short value60 , + int value61 , int value62 , long value63 , int value64 , + long value65 , long value66 , short value67 , int value68 , + short value69 , long value70 , int value71 , int value72 , + int value73 , int value74 , long value75 , int value76 , + long value77 , long value78 , int value79 , long value80 , + short value81 , int value82 , int value83 , long value84 , + long value85 , int value86 , int value87 , long value88 , + long value89 , short value90 , int value91 , int value92 , + long value93 , int value94 , short value95 , short value96 , + short value97 , int value98 , int value99 , long value100, + int value101, short value102, long value103, short value104, + long value105, int value106, long value107, long value108, + int value109, int value110, short value111, long value112, + short value113, long value114, long value115, short value116, + int value117, long value118, short value119, long value120, + short value121, int value122, int value123, short value124, + int value125, long value126, int value127) { + expects(value1, 1); + expects(value2, 2); + expecti(value3, 3); + expects(value4, 4); + expectl(value5, 5); + expects(value6, 6); + expects(value7, 7); + expecti(value8, 8); + expecti(value9, 9); + expects(value10, 10); + expectl(value11, 11); + expects(value12, 12); + expectl(value13, 13); + expects(value14, 14); + expectl(value15, 15); + expects(value16, 16); + expecti(value17, 17); + expecti(value18, 18); + expects(value19, 19); + expects(value20, 20); + expectl(value21, 21); + expectl(value22, 22); + expecti(value23, 23); + expecti(value24, 24); + expectl(value25, 25); + expectl(value26, 26); + expectl(value27, 27); + expects(value28, 28); + expects(value29, 29); + expects(value30, 30); + expectl(value31, 31); + expecti(value32, 32); + expecti(value33, 33); + expecti(value34, 34); + expectl(value35, 35); + expecti(value36, 36); + expects(value37, 37); + expects(value38, 38); + expects(value39, 39); + expects(value40, 40); + expecti(value41, 41); + expecti(value42, 42); + expecti(value43, 43); + expectl(value44, 44); + expectl(value45, 45); + expects(value46, 46); + expectl(value47, 47); + expectl(value48, 48); + expectl(value49, 49); + expecti(value50, 50); + expectl(value51, 51); + expects(value52, 52); + expects(value53, 53); + expectl(value54, 54); + expectl(value55, 55); + expecti(value56, 56); + expectl(value57, 57); + expectl(value58, 58); + expects(value59, 59); + expects(value60, 60); + expecti(value61, 61); + expecti(value62, 62); + expectl(value63, 63); + expecti(value64, 64); + expectl(value65, 65); + expectl(value66, 66); + expects(value67, 67); + expecti(value68, 68); + expects(value69, 69); + expectl(value70, 70); + expecti(value71, 71); + expecti(value72, 72); + expecti(value73, 73); + expecti(value74, 74); + expectl(value75, 75); + expecti(value76, 76); + expectl(value77, 77); + expectl(value78, 78); + expecti(value79, 79); + expectl(value80, 80); + expects(value81, 81); + expecti(value82, 82); + expecti(value83, 83); + expectl(value84, 84); + expectl(value85, 85); + expecti(value86, 86); + expecti(value87, 87); + expectl(value88, 88); + expectl(value89, 89); + expects(value90, 90); + expecti(value91, 91); + expecti(value92, 92); + expectl(value93, 93); + expecti(value94, 94); + expects(value95, 95); + expects(value96, 96); + expects(value97, 97); + expecti(value98, 98); + expecti(value99, 99); + expectl(value100, 100); + expecti(value101, 101); + expects(value102, 102); + expectl(value103, 103); + expects(value104, 104); + expectl(value105, 105); + expecti(value106, 106); + expectl(value107, 107); + expectl(value108, 108); + expecti(value109, 109); + expecti(value110, 110); + expects(value111, 111); + expectl(value112, 112); + expects(value113, 113); + expectl(value114, 114); + expectl(value115, 115); + expects(value116, 116); + expecti(value117, 117); + expectl(value118, 118); + expects(value119, 119); + expectl(value120, 120); + expects(value121, 121); + expecti(value122, 122); + expecti(value123, 123); + expects(value124, 124); + expecti(value125, 125); + expectl(value126, 126); + expecti(value127, 127); +} +int main(void) { + test_int(1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , + 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , + 17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 , + 25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 , + 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , + 41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 , + 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , + 57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 , + 65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , + 73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , + 81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 , + 89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 , + 97 , 98 , 99 , 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, + ); + test_short(1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , + 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , + 17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 , + 25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 , + 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , + 41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 , + 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , + 57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 , + 65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , + 73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , + 81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 , + 89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 , + 97 , 98 , 99 , 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, + ); + test_long(1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , + 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , + 17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 , + 25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 , + 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , + 41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 , + 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , + 57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 , + 65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , + 73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , + 81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 , + 89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 , + 97 , 98 , 99 , 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, + ); + test_mix(1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , + 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , + 17 , 18 , 19 , 20 , 21 , 22 , 23 , 24 , + 25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 , + 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , + 41 , 42 , 43 , 44 , 45 , 46 , 47 , 48 , + 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , + 57 , 58 , 59 , 60 , 61 , 62 , 63 , 64 , + 65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , + 73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , + 81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 , + 89 , 90 , 91 , 92 , 93 , 94 , 95 , 96 , + 97 , 98 , 99 , 100 , 101 , 102 , 103 , 104 , + 105 , 106 , 107 , 108 , 109 , 110 , 111 , 112 , + 113 , 114 , 115 , 116 , 117 , 118 , 119 , 120 , + 121 , 122 , 123 , 124 , 125 , 126 , 127 + ); + return 0; +}