Add files using upload-large-folder tool

.gitattributes

@@ -597,3 +597,7 @@ evalkit_internvl/lib/python3.10/site-packages/transformers/utils/__pycache__/dum
 evalkit_internvl/lib/python3.10/site-packages/transformers/__pycache__/modeling_utils.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_internvl/lib/python3.10/site-packages/transformers/__pycache__/training_args.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_internvl/lib/python3.10/site-packages/transformers/__pycache__/modeling_tf_utils.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_internvl/lib/python3.10/site-packages/transformers/__pycache__/__init__.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_tf449/lib/python3.10/site-packages/triton/backends/nvidia/lib/cupti/libnvperf_host.so filter=lfs diff=lfs merge=lfs -text
+evalkit_internvl/lib/python3.10/site-packages/transformers/utils/__pycache__/dummy_pt_objects.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+evalkit_internvl/lib/python3.10/site-packages/transformers/__pycache__/modeling_outputs.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/_antlr/__init__.py

@@ -0,0 +1,5 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/_antlr/autolevlexer.py

@@ -0,0 +1,253 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    return [
+        4,0,49,393,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,
+        2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,
+        13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,
+        19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,
+        26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,
+        32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,
+        39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,
+        45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,1,0,1,0,1,1,
+        1,1,1,2,1,2,1,3,1,3,1,3,1,4,1,4,1,4,1,5,1,5,1,5,1,6,1,6,1,6,1,7,
+        1,7,1,7,1,8,1,8,1,8,1,9,1,9,1,10,1,10,1,11,1,11,1,12,1,12,1,13,1,
+        13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,19,1,19,1,
+        20,1,20,1,21,1,21,1,21,1,22,1,22,1,22,1,22,1,23,1,23,1,24,1,24,1,
+        25,1,25,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,
+        27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,184,8,28,1,29,1,29,1,
+        29,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,
+        31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,
+        32,1,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,34,1,
+        34,1,34,1,34,1,34,1,34,3,34,232,8,34,1,35,1,35,1,35,1,35,1,35,1,
+        35,3,35,240,8,35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,
+        36,251,8,36,1,37,1,37,1,37,1,37,1,37,1,37,3,37,259,8,37,1,38,1,38,
+        1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,270,8,38,1,39,1,39,1,39,
+        1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,282,8,39,1,40,1,40,1,40,
+        1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,
+        1,41,1,41,1,41,3,41,303,8,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,
+        1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,320,8,42,1,43,5,43,
+        323,8,43,10,43,12,43,326,9,43,1,44,1,44,1,45,4,45,331,8,45,11,45,
+        12,45,332,1,46,4,46,336,8,46,11,46,12,46,337,1,46,1,46,5,46,342,
+        8,46,10,46,12,46,345,9,46,1,46,1,46,4,46,349,8,46,11,46,12,46,350,
+        3,46,353,8,46,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,
+        364,8,47,1,48,1,48,5,48,368,8,48,10,48,12,48,371,9,48,1,48,3,48,
+        374,8,48,1,48,1,48,1,48,1,48,1,49,1,49,5,49,382,8,49,10,49,12,49,
+        385,9,49,1,50,4,50,388,8,50,11,50,12,50,389,1,50,1,50,1,369,0,51,
+        1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,
+        27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,24,
+        49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,34,69,35,
+        71,36,73,37,75,38,77,39,79,40,81,41,83,42,85,43,87,0,89,0,91,44,
+        93,45,95,46,97,47,99,48,101,49,1,0,24,2,0,77,77,109,109,2,0,65,65,
+        97,97,2,0,83,83,115,115,2,0,73,73,105,105,2,0,78,78,110,110,2,0,
+        69,69,101,101,2,0,82,82,114,114,2,0,84,84,116,116,2,0,80,80,112,
+        112,2,0,85,85,117,117,2,0,79,79,111,111,2,0,86,86,118,118,2,0,89,
+        89,121,121,2,0,67,67,99,99,2,0,68,68,100,100,2,0,87,87,119,119,2,
+        0,70,70,102,102,2,0,66,66,98,98,2,0,76,76,108,108,2,0,71,71,103,
+        103,1,0,48,57,2,0,65,90,97,122,4,0,48,57,65,90,95,95,97,122,4,0,
+        9,10,13,13,32,32,38,38,410,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,
+        7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,
+        1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27,
+        1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,37,
+        1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,
+        1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,
+        1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,67,
+        1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,77,
+        1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0,0,0,91,
+        1,0,0,0,0,93,1,0,0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,
+        1,0,0,0,1,103,1,0,0,0,3,105,1,0,0,0,5,107,1,0,0,0,7,109,1,0,0,0,
+        9,112,1,0,0,0,11,115,1,0,0,0,13,118,1,0,0,0,15,121,1,0,0,0,17,124,
+        1,0,0,0,19,127,1,0,0,0,21,129,1,0,0,0,23,131,1,0,0,0,25,133,1,0,
+        0,0,27,135,1,0,0,0,29,137,1,0,0,0,31,139,1,0,0,0,33,141,1,0,0,0,
+        35,143,1,0,0,0,37,145,1,0,0,0,39,147,1,0,0,0,41,149,1,0,0,0,43,151,
+        1,0,0,0,45,154,1,0,0,0,47,158,1,0,0,0,49,160,1,0,0,0,51,162,1,0,
+        0,0,53,164,1,0,0,0,55,169,1,0,0,0,57,177,1,0,0,0,59,185,1,0,0,0,
+        61,192,1,0,0,0,63,197,1,0,0,0,65,208,1,0,0,0,67,215,1,0,0,0,69,225,
+        1,0,0,0,71,233,1,0,0,0,73,241,1,0,0,0,75,252,1,0,0,0,77,260,1,0,
+        0,0,79,271,1,0,0,0,81,283,1,0,0,0,83,293,1,0,0,0,85,304,1,0,0,0,
+        87,324,1,0,0,0,89,327,1,0,0,0,91,330,1,0,0,0,93,352,1,0,0,0,95,363,
+        1,0,0,0,97,365,1,0,0,0,99,379,1,0,0,0,101,387,1,0,0,0,103,104,5,
+        91,0,0,104,2,1,0,0,0,105,106,5,93,0,0,106,4,1,0,0,0,107,108,5,61,
+        0,0,108,6,1,0,0,0,109,110,5,43,0,0,110,111,5,61,0,0,111,8,1,0,0,
+        0,112,113,5,45,0,0,113,114,5,61,0,0,114,10,1,0,0,0,115,116,5,58,
+        0,0,116,117,5,61,0,0,117,12,1,0,0,0,118,119,5,42,0,0,119,120,5,61,
+        0,0,120,14,1,0,0,0,121,122,5,47,0,0,122,123,5,61,0,0,123,16,1,0,
+        0,0,124,125,5,94,0,0,125,126,5,61,0,0,126,18,1,0,0,0,127,128,5,44,
+        0,0,128,20,1,0,0,0,129,130,5,39,0,0,130,22,1,0,0,0,131,132,5,40,
+        0,0,132,24,1,0,0,0,133,134,5,41,0,0,134,26,1,0,0,0,135,136,5,123,
+        0,0,136,28,1,0,0,0,137,138,5,125,0,0,138,30,1,0,0,0,139,140,5,58,
+        0,0,140,32,1,0,0,0,141,142,5,43,0,0,142,34,1,0,0,0,143,144,5,45,
+        0,0,144,36,1,0,0,0,145,146,5,59,0,0,146,38,1,0,0,0,147,148,5,46,
+        0,0,148,40,1,0,0,0,149,150,5,62,0,0,150,42,1,0,0,0,151,152,5,48,
+        0,0,152,153,5,62,0,0,153,44,1,0,0,0,154,155,5,49,0,0,155,156,5,62,
+        0,0,156,157,5,62,0,0,157,46,1,0,0,0,158,159,5,94,0,0,159,48,1,0,
+        0,0,160,161,5,42,0,0,161,50,1,0,0,0,162,163,5,47,0,0,163,52,1,0,
+        0,0,164,165,7,0,0,0,165,166,7,1,0,0,166,167,7,2,0,0,167,168,7,2,
+        0,0,168,54,1,0,0,0,169,170,7,3,0,0,170,171,7,4,0,0,171,172,7,5,0,
+        0,172,173,7,6,0,0,173,174,7,7,0,0,174,175,7,3,0,0,175,176,7,1,0,
+        0,176,56,1,0,0,0,177,178,7,3,0,0,178,179,7,4,0,0,179,180,7,8,0,0,
+        180,181,7,9,0,0,181,183,7,7,0,0,182,184,7,2,0,0,183,182,1,0,0,0,
+        183,184,1,0,0,0,184,58,1,0,0,0,185,186,7,10,0,0,186,187,7,9,0,0,
+        187,188,7,7,0,0,188,189,7,8,0,0,189,190,7,9,0,0,190,191,7,7,0,0,
+        191,60,1,0,0,0,192,193,7,2,0,0,193,194,7,1,0,0,194,195,7,11,0,0,
+        195,196,7,5,0,0,196,62,1,0,0,0,197,198,7,9,0,0,198,199,7,4,0,0,199,
+        200,7,3,0,0,200,201,7,7,0,0,201,202,7,2,0,0,202,203,7,12,0,0,203,
+        204,7,2,0,0,204,205,7,7,0,0,205,206,7,5,0,0,206,207,7,0,0,0,207,
+        64,1,0,0,0,208,209,7,5,0,0,209,210,7,4,0,0,210,211,7,13,0,0,211,
+        212,7,10,0,0,212,213,7,14,0,0,213,214,7,5,0,0,214,66,1,0,0,0,215,
+        216,7,4,0,0,216,217,7,5,0,0,217,218,7,15,0,0,218,219,7,7,0,0,219,
+        220,7,10,0,0,220,221,7,4,0,0,221,222,7,3,0,0,222,223,7,1,0,0,223,
+        224,7,4,0,0,224,68,1,0,0,0,225,226,7,16,0,0,226,227,7,6,0,0,227,
+        228,7,1,0,0,228,229,7,0,0,0,229,231,7,5,0,0,230,232,7,2,0,0,231,
+        230,1,0,0,0,231,232,1,0,0,0,232,70,1,0,0,0,233,234,7,17,0,0,234,
+        235,7,10,0,0,235,236,7,14,0,0,236,237,7,3,0,0,237,239,7,5,0,0,238,
+        240,7,2,0,0,239,238,1,0,0,0,239,240,1,0,0,0,240,72,1,0,0,0,241,242,
+        7,8,0,0,242,243,7,1,0,0,243,244,7,6,0,0,244,245,7,7,0,0,245,246,
+        7,3,0,0,246,247,7,13,0,0,247,248,7,18,0,0,248,250,7,5,0,0,249,251,
+        7,2,0,0,250,249,1,0,0,0,250,251,1,0,0,0,251,74,1,0,0,0,252,253,7,
+        8,0,0,253,254,7,10,0,0,254,255,7,3,0,0,255,256,7,4,0,0,256,258,7,
+        7,0,0,257,259,7,2,0,0,258,257,1,0,0,0,258,259,1,0,0,0,259,76,1,0,
+        0,0,260,261,7,13,0,0,261,262,7,10,0,0,262,263,7,4,0,0,263,264,7,
+        2,0,0,264,265,7,7,0,0,265,266,7,1,0,0,266,267,7,4,0,0,267,269,7,
+        7,0,0,268,270,7,2,0,0,269,268,1,0,0,0,269,270,1,0,0,0,270,78,1,0,
+        0,0,271,272,7,2,0,0,272,273,7,8,0,0,273,274,7,5,0,0,274,275,7,13,
+        0,0,275,276,7,3,0,0,276,277,7,16,0,0,277,278,7,3,0,0,278,279,7,5,
+        0,0,279,281,7,14,0,0,280,282,7,2,0,0,281,280,1,0,0,0,281,282,1,0,
+        0,0,282,80,1,0,0,0,283,284,7,3,0,0,284,285,7,0,0,0,285,286,7,1,0,
+        0,286,287,7,19,0,0,287,288,7,3,0,0,288,289,7,4,0,0,289,290,7,1,0,
+        0,290,291,7,6,0,0,291,292,7,12,0,0,292,82,1,0,0,0,293,294,7,11,0,
+        0,294,295,7,1,0,0,295,296,7,6,0,0,296,297,7,3,0,0,297,298,7,1,0,
+        0,298,299,7,17,0,0,299,300,7,18,0,0,300,302,7,5,0,0,301,303,7,2,
+        0,0,302,301,1,0,0,0,302,303,1,0,0,0,303,84,1,0,0,0,304,305,7,0,0,
+        0,305,306,7,10,0,0,306,307,7,7,0,0,307,308,7,3,0,0,308,309,7,10,
+        0,0,309,310,7,4,0,0,310,311,7,11,0,0,311,312,7,1,0,0,312,313,7,6,
+        0,0,313,314,7,3,0,0,314,315,7,1,0,0,315,316,7,17,0,0,316,317,7,18,
+        0,0,317,319,7,5,0,0,318,320,7,2,0,0,319,318,1,0,0,0,319,320,1,0,
+        0,0,320,86,1,0,0,0,321,323,5,39,0,0,322,321,1,0,0,0,323,326,1,0,
+        0,0,324,322,1,0,0,0,324,325,1,0,0,0,325,88,1,0,0,0,326,324,1,0,0,
+        0,327,328,7,20,0,0,328,90,1,0,0,0,329,331,7,20,0,0,330,329,1,0,0,
+        0,331,332,1,0,0,0,332,330,1,0,0,0,332,333,1,0,0,0,333,92,1,0,0,0,
+        334,336,3,89,44,0,335,334,1,0,0,0,336,337,1,0,0,0,337,335,1,0,0,
+        0,337,338,1,0,0,0,338,339,1,0,0,0,339,343,5,46,0,0,340,342,3,89,
+        44,0,341,340,1,0,0,0,342,345,1,0,0,0,343,341,1,0,0,0,343,344,1,0,
+        0,0,344,353,1,0,0,0,345,343,1,0,0,0,346,348,5,46,0,0,347,349,3,89,
+        44,0,348,347,1,0,0,0,349,350,1,0,0,0,350,348,1,0,0,0,350,351,1,0,
+        0,0,351,353,1,0,0,0,352,335,1,0,0,0,352,346,1,0,0,0,353,94,1,0,0,
+        0,354,355,3,93,46,0,355,356,5,69,0,0,356,357,3,91,45,0,357,364,1,
+        0,0,0,358,359,3,93,46,0,359,360,5,69,0,0,360,361,5,45,0,0,361,362,
+        3,91,45,0,362,364,1,0,0,0,363,354,1,0,0,0,363,358,1,0,0,0,364,96,
+        1,0,0,0,365,369,5,37,0,0,366,368,9,0,0,0,367,366,1,0,0,0,368,371,
+        1,0,0,0,369,370,1,0,0,0,369,367,1,0,0,0,370,373,1,0,0,0,371,369,
+        1,0,0,0,372,374,5,13,0,0,373,372,1,0,0,0,373,374,1,0,0,0,374,375,
+        1,0,0,0,375,376,5,10,0,0,376,377,1,0,0,0,377,378,6,48,0,0,378,98,
+        1,0,0,0,379,383,7,21,0,0,380,382,7,22,0,0,381,380,1,0,0,0,382,385,
+        1,0,0,0,383,381,1,0,0,0,383,384,1,0,0,0,384,100,1,0,0,0,385,383,
+        1,0,0,0,386,388,7,23,0,0,387,386,1,0,0,0,388,389,1,0,0,0,389,387,
+        1,0,0,0,389,390,1,0,0,0,390,391,1,0,0,0,391,392,6,50,0,0,392,102,
+        1,0,0,0,21,0,183,231,239,250,258,269,281,302,319,324,332,337,343,
+        350,352,363,369,373,383,389,1,6,0,0
+    ]
+
+class AutolevLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    T__0 = 1
+    T__1 = 2
+    T__2 = 3
+    T__3 = 4
+    T__4 = 5
+    T__5 = 6
+    T__6 = 7
+    T__7 = 8
+    T__8 = 9
+    T__9 = 10
+    T__10 = 11
+    T__11 = 12
+    T__12 = 13
+    T__13 = 14
+    T__14 = 15
+    T__15 = 16
+    T__16 = 17
+    T__17 = 18
+    T__18 = 19
+    T__19 = 20
+    T__20 = 21
+    T__21 = 22
+    T__22 = 23
+    T__23 = 24
+    T__24 = 25
+    T__25 = 26
+    Mass = 27
+    Inertia = 28
+    Input = 29
+    Output = 30
+    Save = 31
+    UnitSystem = 32
+    Encode = 33
+    Newtonian = 34
+    Frames = 35
+    Bodies = 36
+    Particles = 37
+    Points = 38
+    Constants = 39
+    Specifieds = 40
+    Imaginary = 41
+    Variables = 42
+    MotionVariables = 43
+    INT = 44
+    FLOAT = 45
+    EXP = 46
+    LINE_COMMENT = 47
+    ID = 48
+    WS = 49
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'['", "']'", "'='", "'+='", "'-='", "':='", "'*='", "'/='",
+            "'^='", "','", "'''", "'('", "')'", "'{'", "'}'", "':'", "'+'",
+            "'-'", "';'", "'.'", "'>'", "'0>'", "'1>>'", "'^'", "'*'", "'/'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "Mass", "Inertia", "Input", "Output", "Save", "UnitSystem",
+            "Encode", "Newtonian", "Frames", "Bodies", "Particles", "Points",
+            "Constants", "Specifieds", "Imaginary", "Variables", "MotionVariables",
+            "INT", "FLOAT", "EXP", "LINE_COMMENT", "ID", "WS" ]
+
+    ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
+                  "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13",
+                  "T__14", "T__15", "T__16", "T__17", "T__18", "T__19",
+                  "T__20", "T__21", "T__22", "T__23", "T__24", "T__25",
+                  "Mass", "Inertia", "Input", "Output", "Save", "UnitSystem",
+                  "Encode", "Newtonian", "Frames", "Bodies", "Particles",
+                  "Points", "Constants", "Specifieds", "Imaginary", "Variables",
+                  "MotionVariables", "DIFF", "DIGIT", "INT", "FLOAT", "EXP",
+                  "LINE_COMMENT", "ID", "WS" ]
+
+    grammarFileName = "Autolev.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.11.1")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/_antlr/autolevlistener.py

@@ -0,0 +1,421 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .autolevparser import AutolevParser
+else:
+    from autolevparser import AutolevParser
+
+# This class defines a complete listener for a parse tree produced by AutolevParser.
+class AutolevListener(ParseTreeListener):
+
+    # Enter a parse tree produced by AutolevParser#prog.
+    def enterProg(self, ctx:AutolevParser.ProgContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#prog.
+    def exitProg(self, ctx:AutolevParser.ProgContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#stat.
+    def enterStat(self, ctx:AutolevParser.StatContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#stat.
+    def exitStat(self, ctx:AutolevParser.StatContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#vecAssign.
+    def enterVecAssign(self, ctx:AutolevParser.VecAssignContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#vecAssign.
+    def exitVecAssign(self, ctx:AutolevParser.VecAssignContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#indexAssign.
+    def enterIndexAssign(self, ctx:AutolevParser.IndexAssignContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#indexAssign.
+    def exitIndexAssign(self, ctx:AutolevParser.IndexAssignContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#regularAssign.
+    def enterRegularAssign(self, ctx:AutolevParser.RegularAssignContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#regularAssign.
+    def exitRegularAssign(self, ctx:AutolevParser.RegularAssignContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#equals.
+    def enterEquals(self, ctx:AutolevParser.EqualsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#equals.
+    def exitEquals(self, ctx:AutolevParser.EqualsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#index.
+    def enterIndex(self, ctx:AutolevParser.IndexContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#index.
+    def exitIndex(self, ctx:AutolevParser.IndexContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#diff.
+    def enterDiff(self, ctx:AutolevParser.DiffContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#diff.
+    def exitDiff(self, ctx:AutolevParser.DiffContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#functionCall.
+    def enterFunctionCall(self, ctx:AutolevParser.FunctionCallContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#functionCall.
+    def exitFunctionCall(self, ctx:AutolevParser.FunctionCallContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#varDecl.
+    def enterVarDecl(self, ctx:AutolevParser.VarDeclContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#varDecl.
+    def exitVarDecl(self, ctx:AutolevParser.VarDeclContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#varType.
+    def enterVarType(self, ctx:AutolevParser.VarTypeContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#varType.
+    def exitVarType(self, ctx:AutolevParser.VarTypeContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#varDecl2.
+    def enterVarDecl2(self, ctx:AutolevParser.VarDecl2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#varDecl2.
+    def exitVarDecl2(self, ctx:AutolevParser.VarDecl2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#ranges.
+    def enterRanges(self, ctx:AutolevParser.RangesContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#ranges.
+    def exitRanges(self, ctx:AutolevParser.RangesContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#massDecl.
+    def enterMassDecl(self, ctx:AutolevParser.MassDeclContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#massDecl.
+    def exitMassDecl(self, ctx:AutolevParser.MassDeclContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#massDecl2.
+    def enterMassDecl2(self, ctx:AutolevParser.MassDecl2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#massDecl2.
+    def exitMassDecl2(self, ctx:AutolevParser.MassDecl2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#inertiaDecl.
+    def enterInertiaDecl(self, ctx:AutolevParser.InertiaDeclContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#inertiaDecl.
+    def exitInertiaDecl(self, ctx:AutolevParser.InertiaDeclContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#matrix.
+    def enterMatrix(self, ctx:AutolevParser.MatrixContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#matrix.
+    def exitMatrix(self, ctx:AutolevParser.MatrixContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#matrixInOutput.
+    def enterMatrixInOutput(self, ctx:AutolevParser.MatrixInOutputContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#matrixInOutput.
+    def exitMatrixInOutput(self, ctx:AutolevParser.MatrixInOutputContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#codeCommands.
+    def enterCodeCommands(self, ctx:AutolevParser.CodeCommandsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#codeCommands.
+    def exitCodeCommands(self, ctx:AutolevParser.CodeCommandsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#settings.
+    def enterSettings(self, ctx:AutolevParser.SettingsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#settings.
+    def exitSettings(self, ctx:AutolevParser.SettingsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#units.
+    def enterUnits(self, ctx:AutolevParser.UnitsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#units.
+    def exitUnits(self, ctx:AutolevParser.UnitsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#inputs.
+    def enterInputs(self, ctx:AutolevParser.InputsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#inputs.
+    def exitInputs(self, ctx:AutolevParser.InputsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#id_diff.
+    def enterId_diff(self, ctx:AutolevParser.Id_diffContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#id_diff.
+    def exitId_diff(self, ctx:AutolevParser.Id_diffContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#inputs2.
+    def enterInputs2(self, ctx:AutolevParser.Inputs2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#inputs2.
+    def exitInputs2(self, ctx:AutolevParser.Inputs2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#outputs.
+    def enterOutputs(self, ctx:AutolevParser.OutputsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#outputs.
+    def exitOutputs(self, ctx:AutolevParser.OutputsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#outputs2.
+    def enterOutputs2(self, ctx:AutolevParser.Outputs2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#outputs2.
+    def exitOutputs2(self, ctx:AutolevParser.Outputs2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#codegen.
+    def enterCodegen(self, ctx:AutolevParser.CodegenContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#codegen.
+    def exitCodegen(self, ctx:AutolevParser.CodegenContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#commands.
+    def enterCommands(self, ctx:AutolevParser.CommandsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#commands.
+    def exitCommands(self, ctx:AutolevParser.CommandsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#vec.
+    def enterVec(self, ctx:AutolevParser.VecContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#vec.
+    def exitVec(self, ctx:AutolevParser.VecContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#parens.
+    def enterParens(self, ctx:AutolevParser.ParensContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#parens.
+    def exitParens(self, ctx:AutolevParser.ParensContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#VectorOrDyadic.
+    def enterVectorOrDyadic(self, ctx:AutolevParser.VectorOrDyadicContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#VectorOrDyadic.
+    def exitVectorOrDyadic(self, ctx:AutolevParser.VectorOrDyadicContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#Exponent.
+    def enterExponent(self, ctx:AutolevParser.ExponentContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#Exponent.
+    def exitExponent(self, ctx:AutolevParser.ExponentContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#MulDiv.
+    def enterMulDiv(self, ctx:AutolevParser.MulDivContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#MulDiv.
+    def exitMulDiv(self, ctx:AutolevParser.MulDivContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#AddSub.
+    def enterAddSub(self, ctx:AutolevParser.AddSubContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#AddSub.
+    def exitAddSub(self, ctx:AutolevParser.AddSubContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#float.
+    def enterFloat(self, ctx:AutolevParser.FloatContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#float.
+    def exitFloat(self, ctx:AutolevParser.FloatContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#int.
+    def enterInt(self, ctx:AutolevParser.IntContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#int.
+    def exitInt(self, ctx:AutolevParser.IntContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#idEqualsExpr.
+    def enterIdEqualsExpr(self, ctx:AutolevParser.IdEqualsExprContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#idEqualsExpr.
+    def exitIdEqualsExpr(self, ctx:AutolevParser.IdEqualsExprContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#negativeOne.
+    def enterNegativeOne(self, ctx:AutolevParser.NegativeOneContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#negativeOne.
+    def exitNegativeOne(self, ctx:AutolevParser.NegativeOneContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#function.
+    def enterFunction(self, ctx:AutolevParser.FunctionContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#function.
+    def exitFunction(self, ctx:AutolevParser.FunctionContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#rangess.
+    def enterRangess(self, ctx:AutolevParser.RangessContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#rangess.
+    def exitRangess(self, ctx:AutolevParser.RangessContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#colon.
+    def enterColon(self, ctx:AutolevParser.ColonContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#colon.
+    def exitColon(self, ctx:AutolevParser.ColonContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#id.
+    def enterId(self, ctx:AutolevParser.IdContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#id.
+    def exitId(self, ctx:AutolevParser.IdContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#exp.
+    def enterExp(self, ctx:AutolevParser.ExpContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#exp.
+    def exitExp(self, ctx:AutolevParser.ExpContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#matrices.
+    def enterMatrices(self, ctx:AutolevParser.MatricesContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#matrices.
+    def exitMatrices(self, ctx:AutolevParser.MatricesContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#Indexing.
+    def enterIndexing(self, ctx:AutolevParser.IndexingContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#Indexing.
+    def exitIndexing(self, ctx:AutolevParser.IndexingContext):
+        pass
+
+
+
+del AutolevParser

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/pydy-example-repo/chaos_pendulum.py

@@ -0,0 +1,55 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+g, lb, w, h = _sm.symbols('g lb w h', real=True)
+theta, phi, omega, alpha = _me.dynamicsymbols('theta phi omega alpha')
+theta_d, phi_d, omega_d, alpha_d = _me.dynamicsymbols('theta_ phi_ omega_ alpha_', 1)
+theta_dd, phi_dd = _me.dynamicsymbols('theta_ phi_', 2)
+frame_n = _me.ReferenceFrame('n')
+body_a_cm = _me.Point('a_cm')
+body_a_cm.set_vel(frame_n, 0)
+body_a_f = _me.ReferenceFrame('a_f')
+body_a = _me.RigidBody('a', body_a_cm, body_a_f, _sm.symbols('m'), (_me.outer(body_a_f.x,body_a_f.x),body_a_cm))
+body_b_cm = _me.Point('b_cm')
+body_b_cm.set_vel(frame_n, 0)
+body_b_f = _me.ReferenceFrame('b_f')
+body_b = _me.RigidBody('b', body_b_cm, body_b_f, _sm.symbols('m'), (_me.outer(body_b_f.x,body_b_f.x),body_b_cm))
+body_a_f.orient(frame_n, 'Axis', [theta, frame_n.y])
+body_b_f.orient(body_a_f, 'Axis', [phi, body_a_f.z])
+point_o = _me.Point('o')
+la = (lb-h/2)/2
+body_a_cm.set_pos(point_o, la*body_a_f.z)
+body_b_cm.set_pos(point_o, lb*body_a_f.z)
+body_a_f.set_ang_vel(frame_n, omega*frame_n.y)
+body_b_f.set_ang_vel(body_a_f, alpha*body_a_f.z)
+point_o.set_vel(frame_n, 0)
+body_a_cm.v2pt_theory(point_o,frame_n,body_a_f)
+body_b_cm.v2pt_theory(point_o,frame_n,body_a_f)
+ma = _sm.symbols('ma')
+body_a.mass = ma
+mb = _sm.symbols('mb')
+body_b.mass = mb
+iaxx = 1/12*ma*(2*la)**2
+iayy = iaxx
+iazz = 0
+ibxx = 1/12*mb*h**2
+ibyy = 1/12*mb*(w**2+h**2)
+ibzz = 1/12*mb*w**2
+body_a.inertia = (_me.inertia(body_a_f, iaxx, iayy, iazz, 0, 0, 0), body_a_cm)
+body_b.inertia = (_me.inertia(body_b_f, ibxx, ibyy, ibzz, 0, 0, 0), body_b_cm)
+force_a = body_a.mass*(g*frame_n.z)
+force_b = body_b.mass*(g*frame_n.z)
+kd_eqs = [theta_d - omega, phi_d - alpha]
+forceList = [(body_a.masscenter,body_a.mass*(g*frame_n.z)), (body_b.masscenter,body_b.mass*(g*frame_n.z))]
+kane = _me.KanesMethod(frame_n, q_ind=[theta,phi], u_ind=[omega, alpha], kd_eqs = kd_eqs)
+fr, frstar = kane.kanes_equations([body_a, body_b], forceList)
+zero = fr+frstar
+from pydy.system import System
+sys = System(kane, constants = {g:9.81, lb:0.2, w:0.2, h:0.1, ma:0.01, mb:0.1},
+specifieds={},
+initial_conditions={theta:_np.deg2rad(90), phi:_np.deg2rad(0.5), omega:0, alpha:0},
+times = _np.linspace(0.0, 10, 10/0.02))
+
+y=sys.integrate()

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/pydy-example-repo/mass_spring_damper.py

@@ -0,0 +1,31 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+m, k, b, g = _sm.symbols('m k b g', real=True)
+position, speed = _me.dynamicsymbols('position speed')
+position_d, speed_d = _me.dynamicsymbols('position_ speed_', 1)
+o = _me.dynamicsymbols('o')
+force = o*_sm.sin(_me.dynamicsymbols._t)
+frame_ceiling = _me.ReferenceFrame('ceiling')
+point_origin = _me.Point('origin')
+point_origin.set_vel(frame_ceiling, 0)
+particle_block = _me.Particle('block', _me.Point('block_pt'), _sm.Symbol('m'))
+particle_block.point.set_pos(point_origin, position*frame_ceiling.x)
+particle_block.mass = m
+particle_block.point.set_vel(frame_ceiling, speed*frame_ceiling.x)
+force_magnitude = m*g-k*position-b*speed+force
+force_block = (force_magnitude*frame_ceiling.x).subs({position_d:speed})
+kd_eqs = [position_d - speed]
+forceList = [(particle_block.point,(force_magnitude*frame_ceiling.x).subs({position_d:speed}))]
+kane = _me.KanesMethod(frame_ceiling, q_ind=[position], u_ind=[speed], kd_eqs = kd_eqs)
+fr, frstar = kane.kanes_equations([particle_block], forceList)
+zero = fr+frstar
+from pydy.system import System
+sys = System(kane, constants = {m:1.0, k:1.0, b:0.2, g:9.8},
+specifieds={_me.dynamicsymbols('t'):lambda x, t: t, o:2},
+initial_conditions={position:0.1, speed:-1*1.0},
+times = _np.linspace(0.0, 10.0, 10.0/0.01))
+
+y=sys.integrate()

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/pydy-example-repo/non_min_pendulum.al

@@ -0,0 +1,20 @@
+MOTIONVARIABLES' Q{2}''
+CONSTANTS L,M,G
+NEWTONIAN N
+POINT PN
+V_PN_N> = 0>
+THETA1 = ATAN(Q2/Q1)
+FRAMES A
+SIMPROT(N, A, 3, THETA1)
+PARTICLES P
+P_PN_P> = Q1*N1>+Q2*N2>
+MASS P=M
+V_P_N>=DT(P_P_PN>, N)
+F_V = DOT(EXPRESS(V_P_N>,A), A1>)
+GRAVITY(G*N1>)
+DEPENDENT[1] = F_V
+CONSTRAIN(DEPENDENT[Q1'])
+ZERO=FR()+FRSTAR()
+F_C = MAG(P_P_PN>)-L
+CONFIG[1]=F_C
+ZERO[2]=CONFIG[1]

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/pydy-example-repo/non_min_pendulum.py

@@ -0,0 +1,36 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+q1, q2 = _me.dynamicsymbols('q1 q2')
+q1_d, q2_d = _me.dynamicsymbols('q1_ q2_', 1)
+q1_dd, q2_dd = _me.dynamicsymbols('q1_ q2_', 2)
+l, m, g = _sm.symbols('l m g', real=True)
+frame_n = _me.ReferenceFrame('n')
+point_pn = _me.Point('pn')
+point_pn.set_vel(frame_n, 0)
+theta1 = _sm.atan(q2/q1)
+frame_a = _me.ReferenceFrame('a')
+frame_a.orient(frame_n, 'Axis', [theta1, frame_n.z])
+particle_p = _me.Particle('p', _me.Point('p_pt'), _sm.Symbol('m'))
+particle_p.point.set_pos(point_pn, q1*frame_n.x+q2*frame_n.y)
+particle_p.mass = m
+particle_p.point.set_vel(frame_n, (point_pn.pos_from(particle_p.point)).dt(frame_n))
+f_v = _me.dot((particle_p.point.vel(frame_n)).express(frame_a), frame_a.x)
+force_p = particle_p.mass*(g*frame_n.x)
+dependent = _sm.Matrix([[0]])
+dependent[0] = f_v
+velocity_constraints = [i for i in dependent]
+u_q1_d = _me.dynamicsymbols('u_q1_d')
+u_q2_d = _me.dynamicsymbols('u_q2_d')
+kd_eqs = [q1_d-u_q1_d, q2_d-u_q2_d]
+forceList = [(particle_p.point,particle_p.mass*(g*frame_n.x))]
+kane = _me.KanesMethod(frame_n, q_ind=[q1,q2], u_ind=[u_q2_d], u_dependent=[u_q1_d], kd_eqs = kd_eqs, velocity_constraints = velocity_constraints)
+fr, frstar = kane.kanes_equations([particle_p], forceList)
+zero = fr+frstar
+f_c = point_pn.pos_from(particle_p.point).magnitude()-l
+config = _sm.Matrix([[0]])
+config[0] = f_c
+zero = zero.row_insert(zero.shape[0], _sm.Matrix([[0]]))
+zero[zero.shape[0]-1] = config[0]

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest10.al

@@ -0,0 +1,58 @@
+% ruletest10.al
+
+VARIABLES X,Y
+COMPLEX ON
+CONSTANTS A,B
+E = A*(B*X+Y)^2
+M = [E;E]
+EXPAND(E)
+EXPAND(M)
+FACTOR(E,X)
+FACTOR(M,X)
+
+EQN[1] = A*X + B*Y
+EQN[2] = 2*A*X - 3*B*Y
+SOLVE(EQN, X, Y)
+RHS_Y = RHS(Y)
+E = (X+Y)^2 + 2*X^2
+ARRANGE(E, 2, X)
+
+CONSTANTS A,B,C
+M = [A,B;C,0]
+M2 = EVALUATE(M,A=1,B=2,C=3)
+EIG(M2, EIGVALUE, EIGVEC)
+
+NEWTONIAN N
+FRAMES A
+SIMPROT(N, A, N1>, X)
+DEGREES OFF
+SIMPROT(N, A, N1>, PI/2)
+
+CONSTANTS C{3}
+V> = C1*A1> + C2*A2> + C3*A3>
+POINTS O, P
+P_P_O> = C1*A1>
+EXPRESS(V>,N)
+EXPRESS(P_P_O>,N)
+W_A_N> = C3*A3>
+ANGVEL(A,N)
+
+V2PTS(N,A,O,P)
+PARTICLES P{2}
+V2PTS(N,A,P1,P2)
+A2PTS(N,A,P1,P)
+
+BODIES B{2}
+CONSTANT G
+GRAVITY(G*N1>)
+
+VARIABLE Z
+V> = X*A1> + Y*A3>
+P_P_O> = X*A1> + Y*A2>
+X = 2*Z
+Y = Z
+EXPLICIT(V>)
+EXPLICIT(P_P_O>)
+
+FORCE(O/P1, X*Y*A1>)
+FORCE(P2, X*Y*A1>)

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest10.py

@@ -0,0 +1,64 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+x, y = _me.dynamicsymbols('x y')
+a, b = _sm.symbols('a b', real=True)
+e = a*(b*x+y)**2
+m = _sm.Matrix([e,e]).reshape(2, 1)
+e = e.expand()
+m = _sm.Matrix([i.expand() for i in m]).reshape((m).shape[0], (m).shape[1])
+e = _sm.factor(e, x)
+m = _sm.Matrix([_sm.factor(i,x) for i in m]).reshape((m).shape[0], (m).shape[1])
+eqn = _sm.Matrix([[0]])
+eqn[0] = a*x+b*y
+eqn = eqn.row_insert(eqn.shape[0], _sm.Matrix([[0]]))
+eqn[eqn.shape[0]-1] = 2*a*x-3*b*y
+print(_sm.solve(eqn,x,y))
+rhs_y = _sm.solve(eqn,x,y)[y]
+e = (x+y)**2+2*x**2
+e.collect(x)
+a, b, c = _sm.symbols('a b c', real=True)
+m = _sm.Matrix([a,b,c,0]).reshape(2, 2)
+m2 = _sm.Matrix([i.subs({a:1,b:2,c:3}) for i in m]).reshape((m).shape[0], (m).shape[1])
+eigvalue = _sm.Matrix([i.evalf() for i in (m2).eigenvals().keys()])
+eigvec = _sm.Matrix([i[2][0].evalf() for i in (m2).eigenvects()]).reshape(m2.shape[0], m2.shape[1])
+frame_n = _me.ReferenceFrame('n')
+frame_a = _me.ReferenceFrame('a')
+frame_a.orient(frame_n, 'Axis', [x, frame_n.x])
+frame_a.orient(frame_n, 'Axis', [_sm.pi/2, frame_n.x])
+c1, c2, c3 = _sm.symbols('c1 c2 c3', real=True)
+v = c1*frame_a.x+c2*frame_a.y+c3*frame_a.z
+point_o = _me.Point('o')
+point_p = _me.Point('p')
+point_o.set_pos(point_p, c1*frame_a.x)
+v = (v).express(frame_n)
+point_o.set_pos(point_p, (point_o.pos_from(point_p)).express(frame_n))
+frame_a.set_ang_vel(frame_n, c3*frame_a.z)
+print(frame_n.ang_vel_in(frame_a))
+point_p.v2pt_theory(point_o,frame_n,frame_a)
+particle_p1 = _me.Particle('p1', _me.Point('p1_pt'), _sm.Symbol('m'))
+particle_p2 = _me.Particle('p2', _me.Point('p2_pt'), _sm.Symbol('m'))
+particle_p2.point.v2pt_theory(particle_p1.point,frame_n,frame_a)
+point_p.a2pt_theory(particle_p1.point,frame_n,frame_a)
+body_b1_cm = _me.Point('b1_cm')
+body_b1_cm.set_vel(frame_n, 0)
+body_b1_f = _me.ReferenceFrame('b1_f')
+body_b1 = _me.RigidBody('b1', body_b1_cm, body_b1_f, _sm.symbols('m'), (_me.outer(body_b1_f.x,body_b1_f.x),body_b1_cm))
+body_b2_cm = _me.Point('b2_cm')
+body_b2_cm.set_vel(frame_n, 0)
+body_b2_f = _me.ReferenceFrame('b2_f')
+body_b2 = _me.RigidBody('b2', body_b2_cm, body_b2_f, _sm.symbols('m'), (_me.outer(body_b2_f.x,body_b2_f.x),body_b2_cm))
+g = _sm.symbols('g', real=True)
+force_p1 = particle_p1.mass*(g*frame_n.x)
+force_p2 = particle_p2.mass*(g*frame_n.x)
+force_b1 = body_b1.mass*(g*frame_n.x)
+force_b2 = body_b2.mass*(g*frame_n.x)
+z = _me.dynamicsymbols('z')
+v = x*frame_a.x+y*frame_a.z
+point_o.set_pos(point_p, x*frame_a.x+y*frame_a.y)
+v = (v).subs({x:2*z, y:z})
+point_o.set_pos(point_p, (point_o.pos_from(point_p)).subs({x:2*z, y:z}))
+force_o = -1*(x*y*frame_a.x)
+force_p1 = particle_p1.mass*(g*frame_n.x)+ x*y*frame_a.x

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest12.py

@@ -0,0 +1,14 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+x, y = _me.dynamicsymbols('x y')
+a, b, r = _sm.symbols('a b r', real=True)
+eqn = _sm.Matrix([[0]])
+eqn[0] = a*x**3+b*y**2-r
+eqn = eqn.row_insert(eqn.shape[0], _sm.Matrix([[0]]))
+eqn[eqn.shape[0]-1] = a*_sm.sin(x)**2+b*_sm.cos(2*y)-r**2
+matrix_list = []
+for i in eqn:matrix_list.append(i.subs({a:2.0, b:3.0, r:1.0}))
+print(_sm.nsolve(matrix_list,(x,y),(_np.deg2rad(30),3.14)))

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest3.al

@@ -0,0 +1,25 @@
+% ruletest3.al
+FRAMES A, B
+NEWTONIAN N
+
+VARIABLES X{3}
+CONSTANTS L
+
+V1> = X1*A1> + X2*A2> + X3*A3>
+V2> = X1*B1> + X2*B2> + X3*B3>
+V3> = X1*N1> + X2*N2> + X3*N3>
+
+V> = V1> + V2> + V3>
+
+POINTS C, D
+POINTS PO{3}
+
+PARTICLES L
+PARTICLES P{3}
+
+BODIES S
+BODIES R{2}
+
+V4> = X1*S1> + X2*S2> + X3*S3>
+
+P_C_SO> = L*N1>

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest3.py

@@ -0,0 +1,37 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+frame_a = _me.ReferenceFrame('a')
+frame_b = _me.ReferenceFrame('b')
+frame_n = _me.ReferenceFrame('n')
+x1, x2, x3 = _me.dynamicsymbols('x1 x2 x3')
+l = _sm.symbols('l', real=True)
+v1 = x1*frame_a.x+x2*frame_a.y+x3*frame_a.z
+v2 = x1*frame_b.x+x2*frame_b.y+x3*frame_b.z
+v3 = x1*frame_n.x+x2*frame_n.y+x3*frame_n.z
+v = v1+v2+v3
+point_c = _me.Point('c')
+point_d = _me.Point('d')
+point_po1 = _me.Point('po1')
+point_po2 = _me.Point('po2')
+point_po3 = _me.Point('po3')
+particle_l = _me.Particle('l', _me.Point('l_pt'), _sm.Symbol('m'))
+particle_p1 = _me.Particle('p1', _me.Point('p1_pt'), _sm.Symbol('m'))
+particle_p2 = _me.Particle('p2', _me.Point('p2_pt'), _sm.Symbol('m'))
+particle_p3 = _me.Particle('p3', _me.Point('p3_pt'), _sm.Symbol('m'))
+body_s_cm = _me.Point('s_cm')
+body_s_cm.set_vel(frame_n, 0)
+body_s_f = _me.ReferenceFrame('s_f')
+body_s = _me.RigidBody('s', body_s_cm, body_s_f, _sm.symbols('m'), (_me.outer(body_s_f.x,body_s_f.x),body_s_cm))
+body_r1_cm = _me.Point('r1_cm')
+body_r1_cm.set_vel(frame_n, 0)
+body_r1_f = _me.ReferenceFrame('r1_f')
+body_r1 = _me.RigidBody('r1', body_r1_cm, body_r1_f, _sm.symbols('m'), (_me.outer(body_r1_f.x,body_r1_f.x),body_r1_cm))
+body_r2_cm = _me.Point('r2_cm')
+body_r2_cm.set_vel(frame_n, 0)
+body_r2_f = _me.ReferenceFrame('r2_f')
+body_r2 = _me.RigidBody('r2', body_r2_cm, body_r2_f, _sm.symbols('m'), (_me.outer(body_r2_f.x,body_r2_f.x),body_r2_cm))
+v4 = x1*body_s_f.x+x2*body_s_f.y+x3*body_s_f.z
+body_s_cm.set_pos(point_c, l*frame_n.x)

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest4.al

@@ -0,0 +1,20 @@
+% ruletest4.al
+
+FRAMES A, B
+MOTIONVARIABLES Q{3}
+SIMPROT(A, B, 1, Q3)
+DCM = A_B
+M = DCM*3 - A_B
+
+VARIABLES R
+CIRCLE_AREA = PI*R^2
+
+VARIABLES U, A
+VARIABLES X, Y
+S = U*T - 1/2*A*T^2
+
+EXPR1 = 2*A*0.5 - 1.25 + 0.25
+EXPR2 = -X^2 + Y^2 + 0.25*(X+Y)^2
+EXPR3 = 0.5E-10
+
+DYADIC>> = A1>*A1> + A2>*A2> + A3>*A3>

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest4.py

@@ -0,0 +1,20 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+frame_a = _me.ReferenceFrame('a')
+frame_b = _me.ReferenceFrame('b')
+q1, q2, q3 = _me.dynamicsymbols('q1 q2 q3')
+frame_b.orient(frame_a, 'Axis', [q3, frame_a.x])
+dcm = frame_a.dcm(frame_b)
+m = dcm*3-frame_a.dcm(frame_b)
+r = _me.dynamicsymbols('r')
+circle_area = _sm.pi*r**2
+u, a = _me.dynamicsymbols('u a')
+x, y = _me.dynamicsymbols('x y')
+s = u*_me.dynamicsymbols._t-1/2*a*_me.dynamicsymbols._t**2
+expr1 = 2*a*0.5-1.25+0.25
+expr2 = -1*x**2+y**2+0.25*(x+y)**2
+expr3 = 0.5*10**(-10)
+dyadic = _me.outer(frame_a.x, frame_a.x)+_me.outer(frame_a.y, frame_a.y)+_me.outer(frame_a.z, frame_a.z)

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest5.al

@@ -0,0 +1,32 @@
+% ruletest5.al
+VARIABLES X', Y'
+
+E1 = (X+Y)^2 + (X-Y)^3
+E2 = (X-Y)^2
+E3 = X^2 + Y^2 + 2*X*Y
+
+M1 = [E1;E2]
+M2 = [(X+Y)^2,(X-Y)^2]
+M3 = M1 + [X;Y]
+
+AM = EXPAND(M1)
+CM = EXPAND([(X+Y)^2,(X-Y)^2])
+EM = EXPAND(M1 + [X;Y])
+F = EXPAND(E1)
+G = EXPAND(E2)
+
+A = FACTOR(E3, X)
+BM = FACTOR(M1, X)
+CM = FACTOR(M1 + [X;Y], X)
+
+A = D(E3, X)
+B = D(E3, Y)
+CM = D(M2, X)
+DM = D(M1 + [X;Y], X)
+FRAMES A, B
+A_B = [1,0,0;1,0,0;1,0,0]
+V1> = X*A1> + Y*A2> + X*Y*A3>
+E> = D(V1>, X, B)
+FM = DT(M1)
+GM = DT([(X+Y)^2,(X-Y)^2])
+H> = DT(V1>, B)

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest6.py

@@ -0,0 +1,36 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+q1, q2 = _me.dynamicsymbols('q1 q2')
+x, y, z = _me.dynamicsymbols('x y z')
+e = q1+q2
+a = (e).subs({q1:x**2+y**2, q2:x-y})
+e2 = _sm.cos(x)
+e3 = _sm.cos(x*y)
+a = (e2).series(x, 0, 2).removeO()
+b = (e3).series(x, 0, 2).removeO().series(y, 0, 2).removeO()
+e = ((x+y)**2).expand()
+a = (e).subs({q1:x**2+y**2,q2:x-y}).subs({x:1,y:z})
+bm = _sm.Matrix([i.subs({x:1,y:z}) for i in _sm.Matrix([e,2*e]).reshape(2, 1)]).reshape((_sm.Matrix([e,2*e]).reshape(2, 1)).shape[0], (_sm.Matrix([e,2*e]).reshape(2, 1)).shape[1])
+e = q1+q2
+a = (e).subs({q1:x**2+y**2,q2:x-y}).subs({x:2,y:z**2})
+j, k, l = _sm.symbols('j k l', real=True)
+p1 = _sm.Poly(_sm.Matrix([j,k,l]).reshape(1, 3), x)
+p2 = _sm.Poly(j*x+k, x)
+root1 = [i.evalf() for i in _sm.solve(p1, x)]
+root2 = [i.evalf() for i in _sm.solve(_sm.Poly(_sm.Matrix([1,2,3]).reshape(3, 1), x),x)]
+m = _sm.Matrix([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]).reshape(4, 4)
+am = (m).T+m
+bm = _sm.Matrix([i.evalf() for i in (m).eigenvals().keys()])
+c1 = _sm.diag(1,1,1,1)
+c2 = _sm.Matrix([2 if i==j else 0 for i in range(3) for j in range(4)]).reshape(3, 4)
+dm = (m+c1)**(-1)
+e = (m+c1).det()+(_sm.Matrix([1,0,0,1]).reshape(2, 2)).trace()
+f = (m)[1,2]
+a = (m).cols
+bm = (m).col(0)
+cm = _sm.Matrix([(m).T.row(0),(m).T.row(1),(m).T.row(2),(m).T.row(3),(m).T.row(2)])
+dm = (m).row(0)
+em = _sm.Matrix([(m).row(0),(m).row(1),(m).row(2),(m).row(3),(m).row(2)])

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest8.al

@@ -0,0 +1,38 @@
+% ruletest8.al
+FRAMES A
+CONSTANTS C{3}
+A>> = EXPRESS(1>>,A)
+PARTICLES P1, P2
+BODIES R
+R_A = [1,1,1;1,1,0;0,0,1]
+POINT O
+MASS P1=M1, P2=M2, R=MR
+INERTIA R, I1, I2, I3
+P_P1_O> = C1*A1>
+P_P2_O> = C2*A2>
+P_RO_O> = C3*A3>
+A>> = EXPRESS(I_P1_O>>, A)
+A>> = EXPRESS(I_P2_O>>, A)
+A>> = EXPRESS(I_R_O>>, A)
+A>> = EXPRESS(INERTIA(O), A)
+A>> = EXPRESS(INERTIA(O, P1, R), A)
+A>> = EXPRESS(I_R_O>>, A)
+A>> = EXPRESS(I_R_RO>>, A)
+
+P_P1_P2> = C1*A1> + C2*A2>
+P_P1_RO> = C3*A1>
+P_P2_RO> = C3*A2>
+
+B> = CM(O)
+B> = CM(O, P1, R)
+B> = CM(P1)
+
+MOTIONVARIABLES U{3}
+V> = U1*A1> + U2*A2> + U3*A3>
+U> = UNITVEC(V> + C1*A1>)
+V_P1_A> = U1*A1>
+A> = PARTIALS(V_P1_A>, U1)
+
+M = MASS(P1,R)
+M = MASS(P2)
+M = MASS()

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/c/c_parser.py

@@ -0,0 +1,1058 @@
+from sympy.external import import_module
+import os
+
+cin = import_module('clang.cindex', import_kwargs = {'fromlist': ['cindex']})
+
+"""
+This module contains all the necessary Classes and Function used to Parse C and
+C++ code into SymPy expression
+The module serves as a backend for SymPyExpression to parse C code
+It is also dependent on Clang's AST and SymPy's Codegen AST.
+The module only supports the features currently supported by the Clang and
+codegen AST which will be updated as the development of codegen AST and this
+module progresses.
+You might find unexpected bugs and exceptions while using the module, feel free
+to report them to the SymPy Issue Tracker
+
+Features Supported
+==================
+
+- Variable Declarations (integers and reals)
+- Assignment (using integer & floating literal and function calls)
+- Function Definitions and Declaration
+- Function Calls
+- Compound statements, Return statements
+
+Notes
+=====
+
+The module is dependent on an external dependency which needs to be installed
+to use the features of this module.
+
+Clang: The C and C++ compiler which is used to extract an AST from the provided
+C source code.
+
+References
+==========
+
+.. [1] https://github.com/sympy/sympy/issues
+.. [2] https://clang.llvm.org/docs/
+.. [3] https://clang.llvm.org/docs/IntroductionToTheClangAST.html
+
+"""
+
+if cin:
+    from sympy.codegen.ast import (Variable, Integer, Float,
+        FunctionPrototype, FunctionDefinition, FunctionCall,
+        none, Return, Assignment, intc, int8, int16, int64,
+        uint8, uint16, uint32, uint64, float32, float64, float80,
+        aug_assign, bool_, While, CodeBlock)
+    from sympy.codegen.cnodes import (PreDecrement, PostDecrement,
+        PreIncrement, PostIncrement)
+    from sympy.core import Add, Mod, Mul, Pow, Rel
+    from sympy.logic.boolalg import And, as_Boolean, Not, Or
+    from sympy.core.symbol import Symbol
+    from sympy.core.sympify import sympify
+    from sympy.logic.boolalg import (false, true)
+    import sys
+    import tempfile
+
+    class BaseParser:
+        """Base Class for the C parser"""
+
+        def __init__(self):
+            """Initializes the Base parser creating a Clang AST index"""
+            self.index = cin.Index.create()
+
+        def diagnostics(self, out):
+            """Diagostics function for the Clang AST"""
+            for diag in self.tu.diagnostics:
+                # tu = translation unit
+                print('%s %s (line %s, col %s) %s' % (
+                        {
+                            4: 'FATAL',
+                            3: 'ERROR',
+                            2: 'WARNING',
+                            1: 'NOTE',
+                            0: 'IGNORED',
+                        }[diag.severity],
+                        diag.location.file,
+                        diag.location.line,
+                        diag.location.column,
+                        diag.spelling
+                    ), file=out)
+
+    class CCodeConverter(BaseParser):
+        """The Code Convereter for Clang AST
+
+        The converter object takes the C source code or file as input and
+        converts them to SymPy Expressions.
+        """
+
+        def __init__(self):
+            """Initializes the code converter"""
+            super().__init__()
+            self._py_nodes = []
+            self._data_types = {
+                "void": {
+                    cin.TypeKind.VOID: none
+                },
+                "bool": {
+                    cin.TypeKind.BOOL: bool_
+                },
+                "int": {
+                    cin.TypeKind.SCHAR: int8,
+                    cin.TypeKind.SHORT: int16,
+                    cin.TypeKind.INT: intc,
+                    cin.TypeKind.LONG: int64,
+                    cin.TypeKind.UCHAR: uint8,
+                    cin.TypeKind.USHORT: uint16,
+                    cin.TypeKind.UINT: uint32,
+                    cin.TypeKind.ULONG: uint64
+                },
+                "float": {
+                    cin.TypeKind.FLOAT: float32,
+                    cin.TypeKind.DOUBLE: float64,
+                    cin.TypeKind.LONGDOUBLE: float80
+                }
+            }
+
+        def parse(self, filename, flags):
+            """Function to parse a file with C source code
+
+            It takes the filename as an attribute and creates a Clang AST
+            Translation Unit parsing the file.
+            Then the transformation function is called on the translation unit,
+            whose reults are collected into a list which is returned by the
+            function.
+
+            Parameters
+            ==========
+
+            filename : string
+                Path to the C file to be parsed
+
+            flags: list
+                Arguments to be passed to Clang while parsing the C code
+
+            Returns
+            =======
+
+            py_nodes: list
+                A list of SymPy AST nodes
+
+            """
+            filepath = os.path.abspath(filename)
+            self.tu = self.index.parse(
+                filepath,
+                args=flags,
+                options=cin.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD
+            )
+            for child in self.tu.cursor.get_children():
+                if child.kind == cin.CursorKind.VAR_DECL or child.kind == cin.CursorKind.FUNCTION_DECL:
+                    self._py_nodes.append(self.transform(child))
+            return self._py_nodes
+
+        def parse_str(self, source, flags):
+            """Function to parse a string with C source code
+
+            It takes the source code as an attribute, stores it in a temporary
+            file and creates a Clang AST Translation Unit parsing the file.
+            Then the transformation function is called on the translation unit,
+            whose reults are collected into a list which is returned by the
+            function.
+
+            Parameters
+            ==========
+
+            source : string
+                A string containing the C source code to be parsed
+
+            flags: list
+                Arguments to be passed to Clang while parsing the C code
+
+            Returns
+            =======
+
+            py_nodes: list
+                A list of SymPy AST nodes
+
+            """
+            file = tempfile.NamedTemporaryFile(mode = 'w+', suffix = '.cpp')
+            file.write(source)
+            file.seek(0)
+            self.tu = self.index.parse(
+                file.name,
+                args=flags,
+                options=cin.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD
+            )
+            file.close()
+            for child in self.tu.cursor.get_children():
+                if child.kind == cin.CursorKind.VAR_DECL or child.kind == cin.CursorKind.FUNCTION_DECL:
+                    self._py_nodes.append(self.transform(child))
+            return self._py_nodes
+
+        def transform(self, node):
+            """Transformation Function for Clang AST nodes
+
+            It determines the kind of node and calls the respective
+            transformation function for that node.
+
+            Raises
+            ======
+
+            NotImplementedError : if the transformation for the provided node
+            is not implemented
+
+            """
+            handler = getattr(self, 'transform_%s' % node.kind.name.lower(), None)
+
+            if handler is None:
+                print(
+                    "Ignoring node of type %s (%s)" % (
+                        node.kind,
+                        ' '.join(
+                            t.spelling for t in node.get_tokens())
+                        ),
+                    file=sys.stderr
+                )
+
+            return handler(node)
+
+        def transform_var_decl(self, node):
+            """Transformation Function for Variable Declaration
+
+            Used to create nodes for variable declarations and assignments with
+            values or function call for the respective nodes in the clang AST
+
+            Returns
+            =======
+
+            A variable node as Declaration, with the initial value if given
+
+            Raises
+            ======
+
+            NotImplementedError : if called for data types not currently
+            implemented
+
+            Notes
+            =====
+
+            The function currently supports following data types:
+
+            Boolean:
+                bool, _Bool
+
+            Integer:
+                8-bit: signed char and unsigned char
+                16-bit: short, short int, signed short,
+                    signed short int, unsigned short, unsigned short int
+                32-bit: int, signed int, unsigned int
+                64-bit: long, long int, signed long,
+                    signed long int, unsigned long, unsigned long int
+
+            Floating point:
+                Single Precision: float
+                Double Precision: double
+                Extended Precision: long double
+
+            """
+            if node.type.kind in self._data_types["int"]:
+                type = self._data_types["int"][node.type.kind]
+            elif node.type.kind in self._data_types["float"]:
+                type = self._data_types["float"][node.type.kind]
+            elif node.type.kind in self._data_types["bool"]:
+                type = self._data_types["bool"][node.type.kind]
+            else:
+                raise NotImplementedError("Only bool, int "
+                    "and float are supported")
+            try:
+                children = node.get_children()
+                child = next(children)
+
+                #ignoring namespace and type details for the variable
+                while child.kind == cin.CursorKind.NAMESPACE_REF or child.kind == cin.CursorKind.TYPE_REF:
+                    child = next(children)
+
+                val = self.transform(child)
+
+                supported_rhs = [
+                    cin.CursorKind.INTEGER_LITERAL,
+                    cin.CursorKind.FLOATING_LITERAL,
+                    cin.CursorKind.UNEXPOSED_EXPR,
+                    cin.CursorKind.BINARY_OPERATOR,
+                    cin.CursorKind.PAREN_EXPR,
+                    cin.CursorKind.UNARY_OPERATOR,
+                    cin.CursorKind.CXX_BOOL_LITERAL_EXPR
+                ]
+
+                if child.kind in supported_rhs:
+                    if isinstance(val, str):
+                        value = Symbol(val)
+                    elif isinstance(val, bool):
+                        if node.type.kind in self._data_types["int"]:
+                            value = Integer(0) if val == False else Integer(1)
+                        elif node.type.kind in self._data_types["float"]:
+                            value = Float(0.0) if val == False else Float(1.0)
+                        elif node.type.kind in self._data_types["bool"]:
+                            value = sympify(val)
+                    elif isinstance(val, (Integer, int, Float, float)):
+                        if node.type.kind in self._data_types["int"]:
+                            value = Integer(val)
+                        elif node.type.kind in self._data_types["float"]:
+                            value = Float(val)
+                        elif node.type.kind in self._data_types["bool"]:
+                            value = sympify(bool(val))
+                    else:
+                        value = val
+
+                    return Variable(
+                    node.spelling
+                    ).as_Declaration(
+                        type = type,
+                        value = value
+                    )
+
+                elif child.kind == cin.CursorKind.CALL_EXPR:
+                    return Variable(
+                        node.spelling
+                        ).as_Declaration(
+                            value = val
+                        )
+
+                else:
+                    raise NotImplementedError("Given "
+                        "variable declaration \"{}\" "
+                        "is not possible to parse yet!"
+                        .format(" ".join(
+                            t.spelling for t in node.get_tokens()
+                            )
+                        ))
+
+            except StopIteration:
+                return Variable(
+                node.spelling
+                ).as_Declaration(
+                    type = type
+                )
+
+        def transform_function_decl(self, node):
+            """Transformation Function For Function Declaration
+
+            Used to create nodes for function declarations and definitions for
+            the respective nodes in the clang AST
+
+            Returns
+            =======
+
+            function : Codegen AST node
+                - FunctionPrototype node if function body is not present
+                - FunctionDefinition node if the function body is present
+
+
+            """
+
+            if node.result_type.kind in self._data_types["int"]:
+                ret_type = self._data_types["int"][node.result_type.kind]
+            elif node.result_type.kind in self._data_types["float"]:
+                ret_type = self._data_types["float"][node.result_type.kind]
+            elif node.result_type.kind in self._data_types["bool"]:
+                ret_type = self._data_types["bool"][node.result_type.kind]
+            elif node.result_type.kind in self._data_types["void"]:
+                ret_type = self._data_types["void"][node.result_type.kind]
+            else:
+                raise NotImplementedError("Only void, bool, int "
+                    "and float are supported")
+            body = []
+            param = []
+
+            # Subsequent nodes will be the parameters for the function.
+            for child in node.get_children():
+                decl = self.transform(child)
+                if child.kind == cin.CursorKind.PARM_DECL:
+                    param.append(decl)
+                elif child.kind == cin.CursorKind.COMPOUND_STMT:
+                    for val in decl:
+                        body.append(val)
+                else:
+                    body.append(decl)
+
+            if body == []:
+                function = FunctionPrototype(
+                    return_type = ret_type,
+                    name = node.spelling,
+                    parameters = param
+                )
+            else:
+                function = FunctionDefinition(
+                    return_type = ret_type,
+                    name = node.spelling,
+                    parameters = param,
+                    body = body
+                )
+            return function
+
+        def transform_parm_decl(self, node):
+            """Transformation function for Parameter Declaration
+
+            Used to create parameter nodes for the required functions for the
+            respective nodes in the clang AST
+
+            Returns
+            =======
+
+            param : Codegen AST Node
+                Variable node with the value and type of the variable
+
+            Raises
+            ======
+
+            ValueError if multiple children encountered in the parameter node
+
+            """
+            if node.type.kind in self._data_types["int"]:
+                type = self._data_types["int"][node.type.kind]
+            elif node.type.kind in self._data_types["float"]:
+                type = self._data_types["float"][node.type.kind]
+            elif node.type.kind in self._data_types["bool"]:
+                type = self._data_types["bool"][node.type.kind]
+            else:
+                raise NotImplementedError("Only bool, int "
+                    "and float are supported")
+            try:
+                children = node.get_children()
+                child = next(children)
+
+                # Any namespace nodes can be ignored
+                while child.kind in [cin.CursorKind.NAMESPACE_REF,
+                                     cin.CursorKind.TYPE_REF,
+                                     cin.CursorKind.TEMPLATE_REF]:
+                    child = next(children)
+
+                # If there is a child, it is the default value of the parameter.
+                lit = self.transform(child)
+                if node.type.kind in self._data_types["int"]:
+                    val = Integer(lit)
+                elif node.type.kind in self._data_types["float"]:
+                    val = Float(lit)
+                elif node.type.kind in self._data_types["bool"]:
+                    val = sympify(bool(lit))
+                else:
+                    raise NotImplementedError("Only bool, int "
+                        "and float are supported")
+
+                param = Variable(
+                    node.spelling
+                ).as_Declaration(
+                    type = type,
+                    value = val
+                )
+            except StopIteration:
+                param = Variable(
+                    node.spelling
+                ).as_Declaration(
+                    type = type
+                )
+
+            try:
+                self.transform(next(children))
+                raise ValueError("Can't handle multiple children on parameter")
+            except StopIteration:
+                pass
+
+            return param
+
+        def transform_integer_literal(self, node):
+            """Transformation function for integer literal
+
+            Used to get the value and type of the given integer literal.
+
+            Returns
+            =======
+
+            val : list
+                List with two arguments type and Value
+                type contains the type of the integer
+                value contains the value stored in the variable
+
+            Notes
+            =====
+
+            Only Base Integer type supported for now
+
+            """
+            try:
+                value = next(node.get_tokens()).spelling
+            except StopIteration:
+                # No tokens
+                value = node.literal
+            return int(value)
+
+        def transform_floating_literal(self, node):
+            """Transformation function for floating literal
+
+            Used to get the value and type of the given floating literal.
+
+            Returns
+            =======
+
+            val : list
+                List with two arguments type and Value
+                type contains the type of float
+                value contains the value stored in the variable
+
+            Notes
+            =====
+
+            Only Base Float type supported for now
+
+            """
+            try:
+                value = next(node.get_tokens()).spelling
+            except (StopIteration, ValueError):
+                # No tokens
+                value = node.literal
+            return float(value)
+
+        def transform_string_literal(self, node):
+            #TODO: No string type in AST
+            #type =
+            #try:
+            #    value = next(node.get_tokens()).spelling
+            #except (StopIteration, ValueError):
+                # No tokens
+            #    value = node.literal
+            #val = [type, value]
+            #return val
+            pass
+
+        def transform_character_literal(self, node):
+            """Transformation function for character literal
+
+            Used to get the value of the given character literal.
+
+            Returns
+            =======
+
+            val : int
+                val contains the ascii value of the character literal
+
+            Notes
+            =====
+
+            Only for cases where character is assigned to a integer value,
+            since character literal is not in SymPy AST
+
+            """
+            try:
+               value = next(node.get_tokens()).spelling
+            except (StopIteration, ValueError):
+                # No tokens
+               value = node.literal
+            return ord(str(value[1]))
+
+        def transform_cxx_bool_literal_expr(self, node):
+            """Transformation function for boolean literal
+
+            Used to get the value of the given boolean literal.
+
+            Returns
+            =======
+
+            value : bool
+                value contains the boolean value of the variable
+
+            """
+            try:
+                value = next(node.get_tokens()).spelling
+            except (StopIteration, ValueError):
+                value = node.literal
+            return True if value == 'true' else False
+
+        def transform_unexposed_decl(self,node):
+            """Transformation function for unexposed declarations"""
+            pass
+
+        def transform_unexposed_expr(self, node):
+            """Transformation function for unexposed expression
+
+            Unexposed expressions are used to wrap float, double literals and
+            expressions
+
+            Returns
+            =======
+
+            expr : Codegen AST Node
+                the result from the wrapped expression
+
+            None : NoneType
+                No childs are found for the node
+
+            Raises
+            ======
+
+            ValueError if the expression contains multiple children
+
+            """
+            # Ignore unexposed nodes; pass whatever is the first
+            # (and should be only) child unaltered.
+            try:
+                children = node.get_children()
+                expr = self.transform(next(children))
+            except StopIteration:
+                return None
+
+            try:
+                next(children)
+                raise ValueError("Unexposed expression has > 1 children.")
+            except StopIteration:
+                pass
+
+            return expr
+
+        def transform_decl_ref_expr(self, node):
+            """Returns the name of the declaration reference"""
+            return node.spelling
+
+        def transform_call_expr(self, node):
+            """Transformation function for a call expression
+
+            Used to create function call nodes for the function calls present
+            in the C code
+
+            Returns
+            =======
+
+            FunctionCall : Codegen AST Node
+                FunctionCall node with parameters if any parameters are present
+
+            """
+            param = []
+            children = node.get_children()
+            child = next(children)
+
+            while child.kind == cin.CursorKind.NAMESPACE_REF:
+                child = next(children)
+            while child.kind == cin.CursorKind.TYPE_REF:
+                child = next(children)
+
+            first_child = self.transform(child)
+            try:
+                for child in children:
+                    arg = self.transform(child)
+                    if child.kind == cin.CursorKind.INTEGER_LITERAL:
+                        param.append(Integer(arg))
+                    elif child.kind == cin.CursorKind.FLOATING_LITERAL:
+                        param.append(Float(arg))
+                    else:
+                        param.append(arg)
+                return FunctionCall(first_child, param)
+
+            except StopIteration:
+                return FunctionCall(first_child)
+
+        def transform_return_stmt(self, node):
+            """Returns the Return Node for a return statement"""
+            return Return(next(node.get_children()).spelling)
+
+        def transform_compound_stmt(self, node):
+            """Transformation function for compond statemets
+
+            Returns
+            =======
+
+            expr : list
+                list of Nodes for the expressions present in the statement
+
+            None : NoneType
+                if the compound statement is empty
+
+            """
+            expr = []
+            children = node.get_children()
+
+            for child in children:
+                expr.append(self.transform(child))
+            return expr
+
+        def transform_decl_stmt(self, node):
+            """Transformation function for declaration statements
+
+            These statements are used to wrap different kinds of declararions
+            like variable or function declaration
+            The function calls the transformer function for the child of the
+            given node
+
+            Returns
+            =======
+
+            statement : Codegen AST Node
+                contains the node returned by the children node for the type of
+                declaration
+
+            Raises
+            ======
+
+            ValueError if multiple children present
+
+            """
+            try:
+                children = node.get_children()
+                statement = self.transform(next(children))
+            except StopIteration:
+                pass
+
+            try:
+                self.transform(next(children))
+                raise ValueError("Don't know how to handle multiple statements")
+            except StopIteration:
+                pass
+
+            return statement
+
+        def transform_paren_expr(self, node):
+            """Transformation function for Parenthesized expressions
+
+            Returns the result from its children nodes
+
+            """
+            return self.transform(next(node.get_children()))
+
+        def transform_compound_assignment_operator(self, node):
+            """Transformation function for handling shorthand operators
+
+            Returns
+            =======
+
+            augmented_assignment_expression: Codegen AST node
+                    shorthand assignment expression represented as Codegen AST
+
+            Raises
+            ======
+
+            NotImplementedError
+                If the shorthand operator for bitwise operators
+                (~=, ^=, &=, |=, <<=, >>=) is encountered
+
+            """
+            return self.transform_binary_operator(node)
+
+        def transform_unary_operator(self, node):
+            """Transformation function for handling unary operators
+
+            Returns
+            =======
+
+            unary_expression: Codegen AST node
+                    simplified unary expression represented as Codegen AST
+
+            Raises
+            ======
+
+            NotImplementedError
+                If dereferencing operator(*), address operator(&) or
+                bitwise NOT operator(~) is encountered
+
+            """
+            # supported operators list
+            operators_list = ['+', '-', '++', '--', '!']
+            tokens = list(node.get_tokens())
+
+            # it can be either pre increment/decrement or any other operator from the list
+            if tokens[0].spelling in operators_list:
+                child = self.transform(next(node.get_children()))
+                # (decl_ref) e.g.; int a = ++b; or simply ++b;
+                if isinstance(child, str):
+                    if tokens[0].spelling == '+':
+                        return Symbol(child)
+                    if tokens[0].spelling == '-':
+                        return Mul(Symbol(child), -1)
+                    if tokens[0].spelling == '++':
+                        return PreIncrement(Symbol(child))
+                    if tokens[0].spelling == '--':
+                        return PreDecrement(Symbol(child))
+                    if tokens[0].spelling == '!':
+                        return Not(Symbol(child))
+                # e.g.; int a = -1; or int b = -(1 + 2);
+                else:
+                    if tokens[0].spelling == '+':
+                        return child
+                    if tokens[0].spelling == '-':
+                        return Mul(child, -1)
+                    if tokens[0].spelling == '!':
+                        return Not(sympify(bool(child)))
+
+            # it can be either post increment/decrement
+            # since variable name is obtained in token[0].spelling
+            elif tokens[1].spelling in ['++', '--']:
+                child = self.transform(next(node.get_children()))
+                if tokens[1].spelling == '++':
+                    return PostIncrement(Symbol(child))
+                if tokens[1].spelling == '--':
+                    return PostDecrement(Symbol(child))
+            else:
+                raise NotImplementedError("Dereferencing operator, "
+                    "Address operator and bitwise NOT operator "
+                    "have not been implemented yet!")
+
+        def transform_binary_operator(self, node):
+            """Transformation function for handling binary operators
+
+            Returns
+            =======
+
+            binary_expression: Codegen AST node
+                    simplified binary expression represented as Codegen AST
+
+            Raises
+            ======
+
+            NotImplementedError
+                If a bitwise operator or
+                unary operator(which is a child of any binary
+                operator in Clang AST) is encountered
+
+            """
+            # get all the tokens of assignment
+            # and store it in the tokens list
+            tokens = list(node.get_tokens())
+
+            # supported operators list
+            operators_list = ['+', '-', '*', '/', '%','=',
+            '>', '>=', '<', '<=', '==', '!=', '&&', '||', '+=', '-=',
+            '*=', '/=', '%=']
+
+            # this stack will contain variable content
+            # and type of variable in the rhs
+            combined_variables_stack = []
+
+            # this stack will contain operators
+            # to be processed in the rhs
+            operators_stack = []
+
+            # iterate through every token
+            for token in tokens:
+                # token is either '(', ')' or
+                # any of the supported operators from the operator list
+                if token.kind == cin.TokenKind.PUNCTUATION:
+
+                    # push '(' to the operators stack
+                    if token.spelling == '(':
+                        operators_stack.append('(')
+
+                    elif token.spelling == ')':
+                        # keep adding the expression to the
+                        # combined variables stack unless
+                        # '(' is found
+                        while (operators_stack
+                            and operators_stack[-1] != '('):
+                            if len(combined_variables_stack) < 2:
+                                raise NotImplementedError(
+                                    "Unary operators as a part of "
+                                    "binary operators is not "
+                                    "supported yet!")
+                            rhs = combined_variables_stack.pop()
+                            lhs = combined_variables_stack.pop()
+                            operator = operators_stack.pop()
+                            combined_variables_stack.append(
+                                self.perform_operation(
+                                lhs, rhs, operator))
+
+                        # pop '('
+                        operators_stack.pop()
+
+                    # token is an operator (supported)
+                    elif token.spelling in operators_list:
+                        while (operators_stack
+                            and self.priority_of(token.spelling)
+                            <= self.priority_of(
+                            operators_stack[-1])):
+                            if len(combined_variables_stack) < 2:
+                                raise NotImplementedError(
+                                    "Unary operators as a part of "
+                                    "binary operators is not "
+                                    "supported yet!")
+                            rhs = combined_variables_stack.pop()
+                            lhs = combined_variables_stack.pop()
+                            operator = operators_stack.pop()
+                            combined_variables_stack.append(
+                                self.perform_operation(
+                                lhs, rhs, operator))
+
+                        # push current operator
+                        operators_stack.append(token.spelling)
+
+                    # token is a bitwise operator
+                    elif token.spelling in ['&', '|', '^', '<<', '>>']:
+                        raise NotImplementedError(
+                            "Bitwise operator has not been "
+                            "implemented yet!")
+
+                    # token is a shorthand bitwise operator
+                    elif token.spelling in ['&=', '|=', '^=', '<<=',
+                    '>>=']:
+                        raise NotImplementedError(
+                            "Shorthand bitwise operator has not been "
+                            "implemented yet!")
+                    else:
+                        raise NotImplementedError(
+                            "Given token {} is not implemented yet!"
+                            .format(token.spelling))
+
+                # token is an identifier(variable)
+                elif token.kind == cin.TokenKind.IDENTIFIER:
+                    combined_variables_stack.append(
+                        [token.spelling, 'identifier'])
+
+                # token is a literal
+                elif token.kind == cin.TokenKind.LITERAL:
+                    combined_variables_stack.append(
+                        [token.spelling, 'literal'])
+
+                # token is a keyword, either true or false
+                elif (token.kind == cin.TokenKind.KEYWORD
+                    and token.spelling in ['true', 'false']):
+                    combined_variables_stack.append(
+                        [token.spelling, 'boolean'])
+                else:
+                    raise NotImplementedError(
+                        "Given token {} is not implemented yet!"
+                        .format(token.spelling))
+
+            # process remaining operators
+            while operators_stack:
+                if len(combined_variables_stack) < 2:
+                    raise NotImplementedError(
+                        "Unary operators as a part of "
+                        "binary operators is not "
+                        "supported yet!")
+                rhs = combined_variables_stack.pop()
+                lhs = combined_variables_stack.pop()
+                operator = operators_stack.pop()
+                combined_variables_stack.append(
+                    self.perform_operation(lhs, rhs, operator))
+
+            return combined_variables_stack[-1][0]
+
+        def priority_of(self, op):
+            """To get the priority of given operator"""
+            if op in ['=', '+=', '-=', '*=', '/=', '%=']:
+                return 1
+            if op in ['&&', '||']:
+                return 2
+            if op in ['<', '<=', '>', '>=', '==', '!=']:
+                return 3
+            if op in ['+', '-']:
+                return 4
+            if op in ['*', '/', '%']:
+                return 5
+            return 0
+
+        def perform_operation(self, lhs, rhs, op):
+            """Performs operation supported by the SymPy core
+
+            Returns
+            =======
+
+            combined_variable: list
+                contains variable content and type of variable
+
+            """
+            lhs_value = self.get_expr_for_operand(lhs)
+            rhs_value = self.get_expr_for_operand(rhs)
+            if op == '+':
+                return [Add(lhs_value, rhs_value), 'expr']
+            if op == '-':
+                return [Add(lhs_value, -rhs_value), 'expr']
+            if op == '*':
+                return [Mul(lhs_value, rhs_value), 'expr']
+            if op == '/':
+                return [Mul(lhs_value, Pow(rhs_value, Integer(-1))), 'expr']
+            if op == '%':
+                return [Mod(lhs_value, rhs_value), 'expr']
+            if op in ['<', '<=', '>', '>=', '==', '!=']:
+                return [Rel(lhs_value, rhs_value, op), 'expr']
+            if op == '&&':
+                return [And(as_Boolean(lhs_value), as_Boolean(rhs_value)), 'expr']
+            if op == '||':
+                return [Or(as_Boolean(lhs_value), as_Boolean(rhs_value)), 'expr']
+            if op == '=':
+                return [Assignment(Variable(lhs_value), rhs_value), 'expr']
+            if op in ['+=', '-=', '*=', '/=', '%=']:
+                return [aug_assign(Variable(lhs_value), op[0], rhs_value), 'expr']
+
+        def get_expr_for_operand(self, combined_variable):
+            """Gives out SymPy Codegen AST node
+
+            AST node returned is corresponding to
+            combined variable passed.Combined variable contains
+            variable content and type of variable
+
+            """
+            if combined_variable[1] == 'identifier':
+                return Symbol(combined_variable[0])
+            if combined_variable[1] == 'literal':
+                if '.' in combined_variable[0]:
+                    return Float(float(combined_variable[0]))
+                else:
+                    return Integer(int(combined_variable[0]))
+            if combined_variable[1] == 'expr':
+                return combined_variable[0]
+            if combined_variable[1] == 'boolean':
+                    return true if combined_variable[0] == 'true' else false
+
+        def transform_null_stmt(self, node):
+            """Handles Null Statement and returns None"""
+            return none
+
+        def transform_while_stmt(self, node):
+            """Transformation function for handling while statement
+
+            Returns
+            =======
+
+            while statement : Codegen AST Node
+                contains the while statement node having condition and
+                statement block
+
+            """
+            children = node.get_children()
+
+            condition = self.transform(next(children))
+            statements = self.transform(next(children))
+
+            if isinstance(statements, list):
+                statement_block = CodeBlock(*statements)
+            else:
+                statement_block = CodeBlock(statements)
+
+            return While(condition, statement_block)
+
+
+
+else:
+    class CCodeConverter():  # type: ignore
+        def __init__(self, *args, **kwargs):
+            raise ImportError("Module not Installed")
+
+
+def parse_c(source):
+    """Function for converting a C source code
+
+    The function reads the source code present in the given file and parses it
+    to give out SymPy Expressions
+
+    Returns
+    =======
+
+    src : list
+        List of Python expression strings
+
+    """
+    converter = CCodeConverter()
+    if os.path.exists(source):
+        src = converter.parse(source, flags = [])
+    else:
+        src = converter.parse_str(source, flags = [])
+    return src

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/latex/_antlr/__init__.py

@@ -0,0 +1,9 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated from ../LaTeX.g4, derived from latex2sympy
+#     latex2sympy is licensed under the MIT license
+#     https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt

evalkit_internvl/lib/python3.10/site-packages/sympy/parsing/latex/_antlr/latexlexer.py

@@ -0,0 +1,512 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated from ../LaTeX.g4, derived from latex2sympy
+#     latex2sympy is licensed under the MIT license
+#     https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    return [
+        4,0,91,911,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,
+        2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,
+        13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,
+        19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,
+        26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,
+        32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,
+        39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,
+        45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,
+        52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,
+        58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,
+        65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,
+        71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,
+        78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,
+        84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,
+        91,7,91,1,0,1,0,1,1,1,1,1,2,4,2,191,8,2,11,2,12,2,192,1,2,1,2,1,
+        3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,209,8,3,1,3,1,
+        3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,224,8,4,1,4,1,
+        4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,241,8,
+        5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,
+        7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,
+        8,1,8,1,8,3,8,277,8,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,
+        9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,
+        1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,
+        1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,
+        381,8,13,1,13,1,13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18,
+        1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1,22,1,23,1,23,1,23,
+        1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,27,
+        1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,
+        1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,31,1,31,
+        1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,3,32,504,8,32,1,33,1,33,1,33,1,33,
+        1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,3,33,521,
+        8,33,1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,
+        1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,
+        1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,
+        1,41,1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,44,1,44,
+        1,44,1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,
+        1,46,1,46,1,46,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,48,1,48,
+        1,48,1,48,1,48,1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,49,1,49,
+        1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,51,1,51,1,51,1,51,
+        1,51,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,
+        1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,
+        1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,57,
+        1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,58,
+        1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,
+        1,60,1,60,1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,62,1,62,
+        1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,
+        1,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,65,
+        1,65,1,66,1,66,1,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,1,67,1,67,
+        1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,753,8,67,
+        1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,69,1,69,1,69,1,69,1,69,1,69,
+        1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,71,1,71,1,71,
+        1,71,1,71,1,71,1,71,1,71,1,72,1,72,1,73,1,73,1,74,1,74,1,75,1,75,
+        1,76,1,76,5,76,796,8,76,10,76,12,76,799,9,76,1,76,1,76,1,76,4,76,
+        804,8,76,11,76,12,76,805,3,76,808,8,76,1,77,1,77,1,78,1,78,1,79,
+        1,79,5,79,816,8,79,10,79,12,79,819,9,79,3,79,821,8,79,1,79,1,79,
+        1,79,5,79,826,8,79,10,79,12,79,829,9,79,1,79,3,79,832,8,79,3,79,
+        834,8,79,1,80,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,
+        1,82,1,82,1,82,1,82,1,82,3,82,852,8,82,1,83,1,83,1,83,1,83,1,83,
+        1,83,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,85,1,85,
+        1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,881,8,86,1,87,
+        1,87,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,
+        1,88,1,88,1,89,1,89,1,90,4,90,902,8,90,11,90,12,90,903,1,91,1,91,
+        4,91,908,8,91,11,91,12,91,909,3,797,817,827,0,92,1,1,3,2,5,3,7,4,
+        9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,15,31,16,
+        33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,24,49,25,51,26,53,27,
+        55,28,57,29,59,30,61,31,63,32,65,33,67,34,69,35,71,36,73,37,75,38,
+        77,39,79,40,81,41,83,42,85,43,87,44,89,45,91,46,93,47,95,48,97,49,
+        99,50,101,51,103,52,105,53,107,54,109,55,111,56,113,57,115,58,117,
+        59,119,60,121,61,123,62,125,63,127,64,129,65,131,66,133,67,135,68,
+        137,69,139,70,141,71,143,72,145,73,147,74,149,75,151,0,153,76,155,
+        77,157,78,159,79,161,80,163,81,165,82,167,83,169,84,171,85,173,86,
+        175,87,177,88,179,89,181,90,183,91,1,0,3,3,0,9,10,13,13,32,32,2,
+        0,65,90,97,122,1,0,48,57,949,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,
+        0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,
+        17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,
+        27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,
+        37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,
+        47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,
+        57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,
+        67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,
+        77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0,0,0,
+        87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0,0,0,0,95,1,0,0,0,0,
+        97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1,0,0,0,0,105,1,0,0,
+        0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0,113,1,0,0,0,0,115,
+        1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0,0,0,0,123,1,0,0,0,
+        0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131,1,0,0,0,0,133,1,
+        0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0,0,141,1,0,0,0,0,
+        143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1,0,0,0,0,153,1,0,
+        0,0,0,155,1,0,0,0,0,157,1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,
+        1,0,0,0,0,165,1,0,0,0,0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,
+        0,173,1,0,0,0,0,175,1,0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,
+        0,0,0,0,183,1,0,0,0,1,185,1,0,0,0,3,187,1,0,0,0,5,190,1,0,0,0,7,
+        208,1,0,0,0,9,223,1,0,0,0,11,240,1,0,0,0,13,244,1,0,0,0,15,252,1,
+        0,0,0,17,276,1,0,0,0,19,280,1,0,0,0,21,295,1,0,0,0,23,312,1,0,0,
+        0,25,320,1,0,0,0,27,380,1,0,0,0,29,384,1,0,0,0,31,386,1,0,0,0,33,
+        388,1,0,0,0,35,390,1,0,0,0,37,392,1,0,0,0,39,394,1,0,0,0,41,396,
+        1,0,0,0,43,398,1,0,0,0,45,400,1,0,0,0,47,403,1,0,0,0,49,406,1,0,
+        0,0,51,408,1,0,0,0,53,410,1,0,0,0,55,412,1,0,0,0,57,420,1,0,0,0,
+        59,427,1,0,0,0,61,435,1,0,0,0,63,443,1,0,0,0,65,503,1,0,0,0,67,520,
+        1,0,0,0,69,522,1,0,0,0,71,527,1,0,0,0,73,533,1,0,0,0,75,538,1,0,
+        0,0,77,543,1,0,0,0,79,547,1,0,0,0,81,551,1,0,0,0,83,556,1,0,0,0,
+        85,561,1,0,0,0,87,566,1,0,0,0,89,571,1,0,0,0,91,576,1,0,0,0,93,581,
+        1,0,0,0,95,589,1,0,0,0,97,597,1,0,0,0,99,605,1,0,0,0,101,613,1,0,
+        0,0,103,621,1,0,0,0,105,629,1,0,0,0,107,635,1,0,0,0,109,641,1,0,
+        0,0,111,647,1,0,0,0,113,655,1,0,0,0,115,663,1,0,0,0,117,671,1,0,
+        0,0,119,679,1,0,0,0,121,687,1,0,0,0,123,694,1,0,0,0,125,701,1,0,
+        0,0,127,707,1,0,0,0,129,717,1,0,0,0,131,724,1,0,0,0,133,730,1,0,
+        0,0,135,752,1,0,0,0,137,754,1,0,0,0,139,761,1,0,0,0,141,769,1,0,
+        0,0,143,777,1,0,0,0,145,785,1,0,0,0,147,787,1,0,0,0,149,789,1,0,
+        0,0,151,791,1,0,0,0,153,793,1,0,0,0,155,809,1,0,0,0,157,811,1,0,
+        0,0,159,833,1,0,0,0,161,835,1,0,0,0,163,840,1,0,0,0,165,851,1,0,
+        0,0,167,853,1,0,0,0,169,859,1,0,0,0,171,869,1,0,0,0,173,880,1,0,
+        0,0,175,882,1,0,0,0,177,888,1,0,0,0,179,898,1,0,0,0,181,901,1,0,
+        0,0,183,905,1,0,0,0,185,186,5,44,0,0,186,2,1,0,0,0,187,188,5,46,
+        0,0,188,4,1,0,0,0,189,191,7,0,0,0,190,189,1,0,0,0,191,192,1,0,0,
+        0,192,190,1,0,0,0,192,193,1,0,0,0,193,194,1,0,0,0,194,195,6,2,0,
+        0,195,6,1,0,0,0,196,197,5,92,0,0,197,209,5,44,0,0,198,199,5,92,0,
+        0,199,200,5,116,0,0,200,201,5,104,0,0,201,202,5,105,0,0,202,203,
+        5,110,0,0,203,204,5,115,0,0,204,205,5,112,0,0,205,206,5,97,0,0,206,
+        207,5,99,0,0,207,209,5,101,0,0,208,196,1,0,0,0,208,198,1,0,0,0,209,
+        210,1,0,0,0,210,211,6,3,0,0,211,8,1,0,0,0,212,213,5,92,0,0,213,224,
+        5,58,0,0,214,215,5,92,0,0,215,216,5,109,0,0,216,217,5,101,0,0,217,
+        218,5,100,0,0,218,219,5,115,0,0,219,220,5,112,0,0,220,221,5,97,0,
+        0,221,222,5,99,0,0,222,224,5,101,0,0,223,212,1,0,0,0,223,214,1,0,
+        0,0,224,225,1,0,0,0,225,226,6,4,0,0,226,10,1,0,0,0,227,228,5,92,
+        0,0,228,241,5,59,0,0,229,230,5,92,0,0,230,231,5,116,0,0,231,232,
+        5,104,0,0,232,233,5,105,0,0,233,234,5,99,0,0,234,235,5,107,0,0,235,
+        236,5,115,0,0,236,237,5,112,0,0,237,238,5,97,0,0,238,239,5,99,0,
+        0,239,241,5,101,0,0,240,227,1,0,0,0,240,229,1,0,0,0,241,242,1,0,
+        0,0,242,243,6,5,0,0,243,12,1,0,0,0,244,245,5,92,0,0,245,246,5,113,
+        0,0,246,247,5,117,0,0,247,248,5,97,0,0,248,249,5,100,0,0,249,250,
+        1,0,0,0,250,251,6,6,0,0,251,14,1,0,0,0,252,253,5,92,0,0,253,254,
+        5,113,0,0,254,255,5,113,0,0,255,256,5,117,0,0,256,257,5,97,0,0,257,
+        258,5,100,0,0,258,259,1,0,0,0,259,260,6,7,0,0,260,16,1,0,0,0,261,
+        262,5,92,0,0,262,277,5,33,0,0,263,264,5,92,0,0,264,265,5,110,0,0,
+        265,266,5,101,0,0,266,267,5,103,0,0,267,268,5,116,0,0,268,269,5,
+        104,0,0,269,270,5,105,0,0,270,271,5,110,0,0,271,272,5,115,0,0,272,
+        273,5,112,0,0,273,274,5,97,0,0,274,275,5,99,0,0,275,277,5,101,0,
+        0,276,261,1,0,0,0,276,263,1,0,0,0,277,278,1,0,0,0,278,279,6,8,0,
+        0,279,18,1,0,0,0,280,281,5,92,0,0,281,282,5,110,0,0,282,283,5,101,
+        0,0,283,284,5,103,0,0,284,285,5,109,0,0,285,286,5,101,0,0,286,287,
+        5,100,0,0,287,288,5,115,0,0,288,289,5,112,0,0,289,290,5,97,0,0,290,
+        291,5,99,0,0,291,292,5,101,0,0,292,293,1,0,0,0,293,294,6,9,0,0,294,
+        20,1,0,0,0,295,296,5,92,0,0,296,297,5,110,0,0,297,298,5,101,0,0,
+        298,299,5,103,0,0,299,300,5,116,0,0,300,301,5,104,0,0,301,302,5,
+        105,0,0,302,303,5,99,0,0,303,304,5,107,0,0,304,305,5,115,0,0,305,
+        306,5,112,0,0,306,307,5,97,0,0,307,308,5,99,0,0,308,309,5,101,0,
+        0,309,310,1,0,0,0,310,311,6,10,0,0,311,22,1,0,0,0,312,313,5,92,0,
+        0,313,314,5,108,0,0,314,315,5,101,0,0,315,316,5,102,0,0,316,317,
+        5,116,0,0,317,318,1,0,0,0,318,319,6,11,0,0,319,24,1,0,0,0,320,321,
+        5,92,0,0,321,322,5,114,0,0,322,323,5,105,0,0,323,324,5,103,0,0,324,
+        325,5,104,0,0,325,326,5,116,0,0,326,327,1,0,0,0,327,328,6,12,0,0,
+        328,26,1,0,0,0,329,330,5,92,0,0,330,331,5,118,0,0,331,332,5,114,
+        0,0,332,333,5,117,0,0,333,334,5,108,0,0,334,381,5,101,0,0,335,336,
+        5,92,0,0,336,337,5,118,0,0,337,338,5,99,0,0,338,339,5,101,0,0,339,
+        340,5,110,0,0,340,341,5,116,0,0,341,342,5,101,0,0,342,381,5,114,
+        0,0,343,344,5,92,0,0,344,345,5,118,0,0,345,346,5,98,0,0,346,347,
+        5,111,0,0,347,381,5,120,0,0,348,349,5,92,0,0,349,350,5,118,0,0,350,
+        351,5,115,0,0,351,352,5,107,0,0,352,353,5,105,0,0,353,381,5,112,
+        0,0,354,355,5,92,0,0,355,356,5,118,0,0,356,357,5,115,0,0,357,358,
+        5,112,0,0,358,359,5,97,0,0,359,360,5,99,0,0,360,381,5,101,0,0,361,
+        362,5,92,0,0,362,363,5,104,0,0,363,364,5,102,0,0,364,365,5,105,0,
+        0,365,381,5,108,0,0,366,367,5,92,0,0,367,381,5,42,0,0,368,369,5,
+        92,0,0,369,381,5,45,0,0,370,371,5,92,0,0,371,381,5,46,0,0,372,373,
+        5,92,0,0,373,381,5,47,0,0,374,375,5,92,0,0,375,381,5,34,0,0,376,
+        377,5,92,0,0,377,381,5,40,0,0,378,379,5,92,0,0,379,381,5,61,0,0,
+        380,329,1,0,0,0,380,335,1,0,0,0,380,343,1,0,0,0,380,348,1,0,0,0,
+        380,354,1,0,0,0,380,361,1,0,0,0,380,366,1,0,0,0,380,368,1,0,0,0,
+        380,370,1,0,0,0,380,372,1,0,0,0,380,374,1,0,0,0,380,376,1,0,0,0,
+        380,378,1,0,0,0,381,382,1,0,0,0,382,383,6,13,0,0,383,28,1,0,0,0,
+        384,385,5,43,0,0,385,30,1,0,0,0,386,387,5,45,0,0,387,32,1,0,0,0,
+        388,389,5,42,0,0,389,34,1,0,0,0,390,391,5,47,0,0,391,36,1,0,0,0,
+        392,393,5,40,0,0,393,38,1,0,0,0,394,395,5,41,0,0,395,40,1,0,0,0,
+        396,397,5,123,0,0,397,42,1,0,0,0,398,399,5,125,0,0,399,44,1,0,0,
+        0,400,401,5,92,0,0,401,402,5,123,0,0,402,46,1,0,0,0,403,404,5,92,
+        0,0,404,405,5,125,0,0,405,48,1,0,0,0,406,407,5,91,0,0,407,50,1,0,
+        0,0,408,409,5,93,0,0,409,52,1,0,0,0,410,411,5,124,0,0,411,54,1,0,
+        0,0,412,413,5,92,0,0,413,414,5,114,0,0,414,415,5,105,0,0,415,416,
+        5,103,0,0,416,417,5,104,0,0,417,418,5,116,0,0,418,419,5,124,0,0,
+        419,56,1,0,0,0,420,421,5,92,0,0,421,422,5,108,0,0,422,423,5,101,
+        0,0,423,424,5,102,0,0,424,425,5,116,0,0,425,426,5,124,0,0,426,58,
+        1,0,0,0,427,428,5,92,0,0,428,429,5,108,0,0,429,430,5,97,0,0,430,
+        431,5,110,0,0,431,432,5,103,0,0,432,433,5,108,0,0,433,434,5,101,
+        0,0,434,60,1,0,0,0,435,436,5,92,0,0,436,437,5,114,0,0,437,438,5,
+        97,0,0,438,439,5,110,0,0,439,440,5,103,0,0,440,441,5,108,0,0,441,
+        442,5,101,0,0,442,62,1,0,0,0,443,444,5,92,0,0,444,445,5,108,0,0,
+        445,446,5,105,0,0,446,447,5,109,0,0,447,64,1,0,0,0,448,449,5,92,
+        0,0,449,450,5,116,0,0,450,504,5,111,0,0,451,452,5,92,0,0,452,453,
+        5,114,0,0,453,454,5,105,0,0,454,455,5,103,0,0,455,456,5,104,0,0,
+        456,457,5,116,0,0,457,458,5,97,0,0,458,459,5,114,0,0,459,460,5,114,
+        0,0,460,461,5,111,0,0,461,504,5,119,0,0,462,463,5,92,0,0,463,464,
+        5,82,0,0,464,465,5,105,0,0,465,466,5,103,0,0,466,467,5,104,0,0,467,
+        468,5,116,0,0,468,469,5,97,0,0,469,470,5,114,0,0,470,471,5,114,0,
+        0,471,472,5,111,0,0,472,504,5,119,0,0,473,474,5,92,0,0,474,475,5,
+        108,0,0,475,476,5,111,0,0,476,477,5,110,0,0,477,478,5,103,0,0,478,
+        479,5,114,0,0,479,480,5,105,0,0,480,481,5,103,0,0,481,482,5,104,
+        0,0,482,483,5,116,0,0,483,484,5,97,0,0,484,485,5,114,0,0,485,486,
+        5,114,0,0,486,487,5,111,0,0,487,504,5,119,0,0,488,489,5,92,0,0,489,
+        490,5,76,0,0,490,491,5,111,0,0,491,492,5,110,0,0,492,493,5,103,0,
+        0,493,494,5,114,0,0,494,495,5,105,0,0,495,496,5,103,0,0,496,497,
+        5,104,0,0,497,498,5,116,0,0,498,499,5,97,0,0,499,500,5,114,0,0,500,
+        501,5,114,0,0,501,502,5,111,0,0,502,504,5,119,0,0,503,448,1,0,0,
+        0,503,451,1,0,0,0,503,462,1,0,0,0,503,473,1,0,0,0,503,488,1,0,0,
+        0,504,66,1,0,0,0,505,506,5,92,0,0,506,507,5,105,0,0,507,508,5,110,
+        0,0,508,521,5,116,0,0,509,510,5,92,0,0,510,511,5,105,0,0,511,512,
+        5,110,0,0,512,513,5,116,0,0,513,514,5,92,0,0,514,515,5,108,0,0,515,
+        516,5,105,0,0,516,517,5,109,0,0,517,518,5,105,0,0,518,519,5,116,
+        0,0,519,521,5,115,0,0,520,505,1,0,0,0,520,509,1,0,0,0,521,68,1,0,
+        0,0,522,523,5,92,0,0,523,524,5,115,0,0,524,525,5,117,0,0,525,526,
+        5,109,0,0,526,70,1,0,0,0,527,528,5,92,0,0,528,529,5,112,0,0,529,
+        530,5,114,0,0,530,531,5,111,0,0,531,532,5,100,0,0,532,72,1,0,0,0,
+        533,534,5,92,0,0,534,535,5,101,0,0,535,536,5,120,0,0,536,537,5,112,
+        0,0,537,74,1,0,0,0,538,539,5,92,0,0,539,540,5,108,0,0,540,541,5,
+        111,0,0,541,542,5,103,0,0,542,76,1,0,0,0,543,544,5,92,0,0,544,545,
+        5,108,0,0,545,546,5,103,0,0,546,78,1,0,0,0,547,548,5,92,0,0,548,
+        549,5,108,0,0,549,550,5,110,0,0,550,80,1,0,0,0,551,552,5,92,0,0,
+        552,553,5,115,0,0,553,554,5,105,0,0,554,555,5,110,0,0,555,82,1,0,
+        0,0,556,557,5,92,0,0,557,558,5,99,0,0,558,559,5,111,0,0,559,560,
+        5,115,0,0,560,84,1,0,0,0,561,562,5,92,0,0,562,563,5,116,0,0,563,
+        564,5,97,0,0,564,565,5,110,0,0,565,86,1,0,0,0,566,567,5,92,0,0,567,
+        568,5,99,0,0,568,569,5,115,0,0,569,570,5,99,0,0,570,88,1,0,0,0,571,
+        572,5,92,0,0,572,573,5,115,0,0,573,574,5,101,0,0,574,575,5,99,0,
+        0,575,90,1,0,0,0,576,577,5,92,0,0,577,578,5,99,0,0,578,579,5,111,
+        0,0,579,580,5,116,0,0,580,92,1,0,0,0,581,582,5,92,0,0,582,583,5,
+        97,0,0,583,584,5,114,0,0,584,585,5,99,0,0,585,586,5,115,0,0,586,
+        587,5,105,0,0,587,588,5,110,0,0,588,94,1,0,0,0,589,590,5,92,0,0,
+        590,591,5,97,0,0,591,592,5,114,0,0,592,593,5,99,0,0,593,594,5,99,
+        0,0,594,595,5,111,0,0,595,596,5,115,0,0,596,96,1,0,0,0,597,598,5,
+        92,0,0,598,599,5,97,0,0,599,600,5,114,0,0,600,601,5,99,0,0,601,602,
+        5,116,0,0,602,603,5,97,0,0,603,604,5,110,0,0,604,98,1,0,0,0,605,
+        606,5,92,0,0,606,607,5,97,0,0,607,608,5,114,0,0,608,609,5,99,0,0,
+        609,610,5,99,0,0,610,611,5,115,0,0,611,612,5,99,0,0,612,100,1,0,
+        0,0,613,614,5,92,0,0,614,615,5,97,0,0,615,616,5,114,0,0,616,617,
+        5,99,0,0,617,618,5,115,0,0,618,619,5,101,0,0,619,620,5,99,0,0,620,
+        102,1,0,0,0,621,622,5,92,0,0,622,623,5,97,0,0,623,624,5,114,0,0,
+        624,625,5,99,0,0,625,626,5,99,0,0,626,627,5,111,0,0,627,628,5,116,
+        0,0,628,104,1,0,0,0,629,630,5,92,0,0,630,631,5,115,0,0,631,632,5,
+        105,0,0,632,633,5,110,0,0,633,634,5,104,0,0,634,106,1,0,0,0,635,
+        636,5,92,0,0,636,637,5,99,0,0,637,638,5,111,0,0,638,639,5,115,0,
+        0,639,640,5,104,0,0,640,108,1,0,0,0,641,642,5,92,0,0,642,643,5,116,
+        0,0,643,644,5,97,0,0,644,645,5,110,0,0,645,646,5,104,0,0,646,110,
+        1,0,0,0,647,648,5,92,0,0,648,649,5,97,0,0,649,650,5,114,0,0,650,
+        651,5,115,0,0,651,652,5,105,0,0,652,653,5,110,0,0,653,654,5,104,
+        0,0,654,112,1,0,0,0,655,656,5,92,0,0,656,657,5,97,0,0,657,658,5,
+        114,0,0,658,659,5,99,0,0,659,660,5,111,0,0,660,661,5,115,0,0,661,
+        662,5,104,0,0,662,114,1,0,0,0,663,664,5,92,0,0,664,665,5,97,0,0,
+        665,666,5,114,0,0,666,667,5,116,0,0,667,668,5,97,0,0,668,669,5,110,
+        0,0,669,670,5,104,0,0,670,116,1,0,0,0,671,672,5,92,0,0,672,673,5,
+        108,0,0,673,674,5,102,0,0,674,675,5,108,0,0,675,676,5,111,0,0,676,
+        677,5,111,0,0,677,678,5,114,0,0,678,118,1,0,0,0,679,680,5,92,0,0,
+        680,681,5,114,0,0,681,682,5,102,0,0,682,683,5,108,0,0,683,684,5,
+        111,0,0,684,685,5,111,0,0,685,686,5,114,0,0,686,120,1,0,0,0,687,
+        688,5,92,0,0,688,689,5,108,0,0,689,690,5,99,0,0,690,691,5,101,0,
+        0,691,692,5,105,0,0,692,693,5,108,0,0,693,122,1,0,0,0,694,695,5,
+        92,0,0,695,696,5,114,0,0,696,697,5,99,0,0,697,698,5,101,0,0,698,
+        699,5,105,0,0,699,700,5,108,0,0,700,124,1,0,0,0,701,702,5,92,0,0,
+        702,703,5,115,0,0,703,704,5,113,0,0,704,705,5,114,0,0,705,706,5,
+        116,0,0,706,126,1,0,0,0,707,708,5,92,0,0,708,709,5,111,0,0,709,710,
+        5,118,0,0,710,711,5,101,0,0,711,712,5,114,0,0,712,713,5,108,0,0,
+        713,714,5,105,0,0,714,715,5,110,0,0,715,716,5,101,0,0,716,128,1,
+        0,0,0,717,718,5,92,0,0,718,719,5,116,0,0,719,720,5,105,0,0,720,721,
+        5,109,0,0,721,722,5,101,0,0,722,723,5,115,0,0,723,130,1,0,0,0,724,
+        725,5,92,0,0,725,726,5,99,0,0,726,727,5,100,0,0,727,728,5,111,0,
+        0,728,729,5,116,0,0,729,132,1,0,0,0,730,731,5,92,0,0,731,732,5,100,
+        0,0,732,733,5,105,0,0,733,734,5,118,0,0,734,134,1,0,0,0,735,736,
+        5,92,0,0,736,737,5,102,0,0,737,738,5,114,0,0,738,739,5,97,0,0,739,
+        753,5,99,0,0,740,741,5,92,0,0,741,742,5,100,0,0,742,743,5,102,0,
+        0,743,744,5,114,0,0,744,745,5,97,0,0,745,753,5,99,0,0,746,747,5,
+        92,0,0,747,748,5,116,0,0,748,749,5,102,0,0,749,750,5,114,0,0,750,
+        751,5,97,0,0,751,753,5,99,0,0,752,735,1,0,0,0,752,740,1,0,0,0,752,
+        746,1,0,0,0,753,136,1,0,0,0,754,755,5,92,0,0,755,756,5,98,0,0,756,
+        757,5,105,0,0,757,758,5,110,0,0,758,759,5,111,0,0,759,760,5,109,
+        0,0,760,138,1,0,0,0,761,762,5,92,0,0,762,763,5,100,0,0,763,764,5,
+        98,0,0,764,765,5,105,0,0,765,766,5,110,0,0,766,767,5,111,0,0,767,
+        768,5,109,0,0,768,140,1,0,0,0,769,770,5,92,0,0,770,771,5,116,0,0,
+        771,772,5,98,0,0,772,773,5,105,0,0,773,774,5,110,0,0,774,775,5,111,
+        0,0,775,776,5,109,0,0,776,142,1,0,0,0,777,778,5,92,0,0,778,779,5,
+        109,0,0,779,780,5,97,0,0,780,781,5,116,0,0,781,782,5,104,0,0,782,
+        783,5,105,0,0,783,784,5,116,0,0,784,144,1,0,0,0,785,786,5,95,0,0,
+        786,146,1,0,0,0,787,788,5,94,0,0,788,148,1,0,0,0,789,790,5,58,0,
+        0,790,150,1,0,0,0,791,792,7,0,0,0,792,152,1,0,0,0,793,797,5,100,
+        0,0,794,796,3,151,75,0,795,794,1,0,0,0,796,799,1,0,0,0,797,798,1,
+        0,0,0,797,795,1,0,0,0,798,807,1,0,0,0,799,797,1,0,0,0,800,808,7,
+        1,0,0,801,803,5,92,0,0,802,804,7,1,0,0,803,802,1,0,0,0,804,805,1,
+        0,0,0,805,803,1,0,0,0,805,806,1,0,0,0,806,808,1,0,0,0,807,800,1,
+        0,0,0,807,801,1,0,0,0,808,154,1,0,0,0,809,810,7,1,0,0,810,156,1,
+        0,0,0,811,812,7,2,0,0,812,158,1,0,0,0,813,817,5,38,0,0,814,816,3,
+        151,75,0,815,814,1,0,0,0,816,819,1,0,0,0,817,818,1,0,0,0,817,815,
+        1,0,0,0,818,821,1,0,0,0,819,817,1,0,0,0,820,813,1,0,0,0,820,821,
+        1,0,0,0,821,822,1,0,0,0,822,834,5,61,0,0,823,831,5,61,0,0,824,826,
+        3,151,75,0,825,824,1,0,0,0,826,829,1,0,0,0,827,828,1,0,0,0,827,825,
+        1,0,0,0,828,830,1,0,0,0,829,827,1,0,0,0,830,832,5,38,0,0,831,827,
+        1,0,0,0,831,832,1,0,0,0,832,834,1,0,0,0,833,820,1,0,0,0,833,823,
+        1,0,0,0,834,160,1,0,0,0,835,836,5,92,0,0,836,837,5,110,0,0,837,838,
+        5,101,0,0,838,839,5,113,0,0,839,162,1,0,0,0,840,841,5,60,0,0,841,
+        164,1,0,0,0,842,843,5,92,0,0,843,844,5,108,0,0,844,845,5,101,0,0,
+        845,852,5,113,0,0,846,847,5,92,0,0,847,848,5,108,0,0,848,852,5,101,
+        0,0,849,852,3,167,83,0,850,852,3,169,84,0,851,842,1,0,0,0,851,846,
+        1,0,0,0,851,849,1,0,0,0,851,850,1,0,0,0,852,166,1,0,0,0,853,854,
+        5,92,0,0,854,855,5,108,0,0,855,856,5,101,0,0,856,857,5,113,0,0,857,
+        858,5,113,0,0,858,168,1,0,0,0,859,860,5,92,0,0,860,861,5,108,0,0,
+        861,862,5,101,0,0,862,863,5,113,0,0,863,864,5,115,0,0,864,865,5,
+        108,0,0,865,866,5,97,0,0,866,867,5,110,0,0,867,868,5,116,0,0,868,
+        170,1,0,0,0,869,870,5,62,0,0,870,172,1,0,0,0,871,872,5,92,0,0,872,
+        873,5,103,0,0,873,874,5,101,0,0,874,881,5,113,0,0,875,876,5,92,0,
+        0,876,877,5,103,0,0,877,881,5,101,0,0,878,881,3,175,87,0,879,881,
+        3,177,88,0,880,871,1,0,0,0,880,875,1,0,0,0,880,878,1,0,0,0,880,879,
+        1,0,0,0,881,174,1,0,0,0,882,883,5,92,0,0,883,884,5,103,0,0,884,885,
+        5,101,0,0,885,886,5,113,0,0,886,887,5,113,0,0,887,176,1,0,0,0,888,
+        889,5,92,0,0,889,890,5,103,0,0,890,891,5,101,0,0,891,892,5,113,0,
+        0,892,893,5,115,0,0,893,894,5,108,0,0,894,895,5,97,0,0,895,896,5,
+        110,0,0,896,897,5,116,0,0,897,178,1,0,0,0,898,899,5,33,0,0,899,180,
+        1,0,0,0,900,902,5,39,0,0,901,900,1,0,0,0,902,903,1,0,0,0,903,901,
+        1,0,0,0,903,904,1,0,0,0,904,182,1,0,0,0,905,907,5,92,0,0,906,908,
+        7,1,0,0,907,906,1,0,0,0,908,909,1,0,0,0,909,907,1,0,0,0,909,910,
+        1,0,0,0,910,184,1,0,0,0,22,0,192,208,223,240,276,380,503,520,752,
+        797,805,807,817,820,827,831,833,851,880,903,909,1,6,0,0
+    ]
+
+class LaTeXLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    T__0 = 1
+    T__1 = 2
+    WS = 3
+    THINSPACE = 4
+    MEDSPACE = 5
+    THICKSPACE = 6
+    QUAD = 7
+    QQUAD = 8
+    NEGTHINSPACE = 9
+    NEGMEDSPACE = 10
+    NEGTHICKSPACE = 11
+    CMD_LEFT = 12
+    CMD_RIGHT = 13
+    IGNORE = 14
+    ADD = 15
+    SUB = 16
+    MUL = 17
+    DIV = 18
+    L_PAREN = 19
+    R_PAREN = 20
+    L_BRACE = 21
+    R_BRACE = 22
+    L_BRACE_LITERAL = 23
+    R_BRACE_LITERAL = 24
+    L_BRACKET = 25
+    R_BRACKET = 26
+    BAR = 27
+    R_BAR = 28
+    L_BAR = 29
+    L_ANGLE = 30
+    R_ANGLE = 31
+    FUNC_LIM = 32
+    LIM_APPROACH_SYM = 33
+    FUNC_INT = 34
+    FUNC_SUM = 35
+    FUNC_PROD = 36
+    FUNC_EXP = 37
+    FUNC_LOG = 38
+    FUNC_LG = 39
+    FUNC_LN = 40
+    FUNC_SIN = 41
+    FUNC_COS = 42
+    FUNC_TAN = 43
+    FUNC_CSC = 44
+    FUNC_SEC = 45
+    FUNC_COT = 46
+    FUNC_ARCSIN = 47
+    FUNC_ARCCOS = 48
+    FUNC_ARCTAN = 49
+    FUNC_ARCCSC = 50
+    FUNC_ARCSEC = 51
+    FUNC_ARCCOT = 52
+    FUNC_SINH = 53
+    FUNC_COSH = 54
+    FUNC_TANH = 55
+    FUNC_ARSINH = 56
+    FUNC_ARCOSH = 57
+    FUNC_ARTANH = 58
+    L_FLOOR = 59
+    R_FLOOR = 60
+    L_CEIL = 61
+    R_CEIL = 62
+    FUNC_SQRT = 63
+    FUNC_OVERLINE = 64
+    CMD_TIMES = 65
+    CMD_CDOT = 66
+    CMD_DIV = 67
+    CMD_FRAC = 68
+    CMD_BINOM = 69
+    CMD_DBINOM = 70
+    CMD_TBINOM = 71
+    CMD_MATHIT = 72
+    UNDERSCORE = 73
+    CARET = 74
+    COLON = 75
+    DIFFERENTIAL = 76
+    LETTER = 77
+    DIGIT = 78
+    EQUAL = 79
+    NEQ = 80
+    LT = 81
+    LTE = 82
+    LTE_Q = 83
+    LTE_S = 84
+    GT = 85
+    GTE = 86
+    GTE_Q = 87
+    GTE_S = 88
+    BANG = 89
+    SINGLE_QUOTES = 90
+    SYMBOL = 91
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "','", "'.'", "'\\quad'", "'\\qquad'", "'\\negmedspace'", "'\\negthickspace'",
+            "'\\left'", "'\\right'", "'+'", "'-'", "'*'", "'/'", "'('",
+            "')'", "'{'", "'}'", "'\\{'", "'\\}'", "'['", "']'", "'|'",
+            "'\\right|'", "'\\left|'", "'\\langle'", "'\\rangle'", "'\\lim'",
+            "'\\sum'", "'\\prod'", "'\\exp'", "'\\log'", "'\\lg'", "'\\ln'",
+            "'\\sin'", "'\\cos'", "'\\tan'", "'\\csc'", "'\\sec'", "'\\cot'",
+            "'\\arcsin'", "'\\arccos'", "'\\arctan'", "'\\arccsc'", "'\\arcsec'",
+            "'\\arccot'", "'\\sinh'", "'\\cosh'", "'\\tanh'", "'\\arsinh'",
+            "'\\arcosh'", "'\\artanh'", "'\\lfloor'", "'\\rfloor'", "'\\lceil'",
+            "'\\rceil'", "'\\sqrt'", "'\\overline'", "'\\times'", "'\\cdot'",
+            "'\\div'", "'\\binom'", "'\\dbinom'", "'\\tbinom'", "'\\mathit'",
+            "'_'", "'^'", "':'", "'\\neq'", "'<'", "'\\leqq'", "'\\leqslant'",
+            "'>'", "'\\geqq'", "'\\geqslant'", "'!'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "WS", "THINSPACE", "MEDSPACE", "THICKSPACE", "QUAD", "QQUAD",
+            "NEGTHINSPACE", "NEGMEDSPACE", "NEGTHICKSPACE", "CMD_LEFT",
+            "CMD_RIGHT", "IGNORE", "ADD", "SUB", "MUL", "DIV", "L_PAREN",
+            "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACE_LITERAL", "R_BRACE_LITERAL",
+            "L_BRACKET", "R_BRACKET", "BAR", "R_BAR", "L_BAR", "L_ANGLE",
+            "R_ANGLE", "FUNC_LIM", "LIM_APPROACH_SYM", "FUNC_INT", "FUNC_SUM",
+            "FUNC_PROD", "FUNC_EXP", "FUNC_LOG", "FUNC_LG", "FUNC_LN", "FUNC_SIN",
+            "FUNC_COS", "FUNC_TAN", "FUNC_CSC", "FUNC_SEC", "FUNC_COT",
+            "FUNC_ARCSIN", "FUNC_ARCCOS", "FUNC_ARCTAN", "FUNC_ARCCSC",
+            "FUNC_ARCSEC", "FUNC_ARCCOT", "FUNC_SINH", "FUNC_COSH", "FUNC_TANH",
+            "FUNC_ARSINH", "FUNC_ARCOSH", "FUNC_ARTANH", "L_FLOOR", "R_FLOOR",
+            "L_CEIL", "R_CEIL", "FUNC_SQRT", "FUNC_OVERLINE", "CMD_TIMES",
+            "CMD_CDOT", "CMD_DIV", "CMD_FRAC", "CMD_BINOM", "CMD_DBINOM",
+            "CMD_TBINOM", "CMD_MATHIT", "UNDERSCORE", "CARET", "COLON",
+            "DIFFERENTIAL", "LETTER", "DIGIT", "EQUAL", "NEQ", "LT", "LTE",
+            "LTE_Q", "LTE_S", "GT", "GTE", "GTE_Q", "GTE_S", "BANG", "SINGLE_QUOTES",
+            "SYMBOL" ]
+
+    ruleNames = [ "T__0", "T__1", "WS", "THINSPACE", "MEDSPACE", "THICKSPACE",
+                  "QUAD", "QQUAD", "NEGTHINSPACE", "NEGMEDSPACE", "NEGTHICKSPACE",
+                  "CMD_LEFT", "CMD_RIGHT", "IGNORE", "ADD", "SUB", "MUL",
+                  "DIV", "L_PAREN", "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACE_LITERAL",
+                  "R_BRACE_LITERAL", "L_BRACKET", "R_BRACKET", "BAR", "R_BAR",
+                  "L_BAR", "L_ANGLE", "R_ANGLE", "FUNC_LIM", "LIM_APPROACH_SYM",
+                  "FUNC_INT", "FUNC_SUM", "FUNC_PROD", "FUNC_EXP", "FUNC_LOG",
+                  "FUNC_LG", "FUNC_LN", "FUNC_SIN", "FUNC_COS", "FUNC_TAN",
+                  "FUNC_CSC", "FUNC_SEC", "FUNC_COT", "FUNC_ARCSIN", "FUNC_ARCCOS",
+                  "FUNC_ARCTAN", "FUNC_ARCCSC", "FUNC_ARCSEC", "FUNC_ARCCOT",
+                  "FUNC_SINH", "FUNC_COSH", "FUNC_TANH", "FUNC_ARSINH",
+                  "FUNC_ARCOSH", "FUNC_ARTANH", "L_FLOOR", "R_FLOOR", "L_CEIL",
+                  "R_CEIL", "FUNC_SQRT", "FUNC_OVERLINE", "CMD_TIMES", "CMD_CDOT",
+                  "CMD_DIV", "CMD_FRAC", "CMD_BINOM", "CMD_DBINOM", "CMD_TBINOM",
+                  "CMD_MATHIT", "UNDERSCORE", "CARET", "COLON", "WS_CHAR",
+                  "DIFFERENTIAL", "LETTER", "DIGIT", "EQUAL", "NEQ", "LT",
+                  "LTE", "LTE_Q", "LTE_S", "GT", "GTE", "GTE_Q", "GTE_S",
+                  "BANG", "SINGLE_QUOTES", "SYMBOL" ]
+
+    grammarFileName = "LaTeX.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.11.1")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

evalkit_internvl/lib/python3.10/site-packages/transformers/__pycache__/__init__.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2b88ae98be21d7f90d10394434830bd0c1070167ab8f88d34e8ef604c743fea
+size 175048

evalkit_internvl/lib/python3.10/site-packages/transformers/__pycache__/modeling_outputs.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5fb7039846a84f9bee26fe87a21a18ae6cda877744bde6cb9091e82627bae77
+size 109267

evalkit_internvl/lib/python3.10/site-packages/transformers/utils/__pycache__/dummy_pt_objects.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:993980ac00572085bbbfa10f423cd91774b243e7bdc953d36780170f129d85b7
+size 318856

evalkit_tf437/lib/python3.10/site-packages/diffusers/models/transformers/__init__.py

@@ -0,0 +1,9 @@
+from ...utils import is_torch_available
+
+
+if is_torch_available():
+    from .dual_transformer_2d import DualTransformer2DModel
+    from .prior_transformer import PriorTransformer
+    from .t5_film_transformer import T5FilmDecoder
+    from .transformer_2d import Transformer2DModel
+    from .transformer_temporal import TransformerTemporalModel

evalkit_tf437/lib/python3.10/site-packages/diffusers/models/transformers/dual_transformer_2d.py

@@ -0,0 +1,155 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Optional
+
+from torch import nn
+
+from .transformer_2d import Transformer2DModel, Transformer2DModelOutput
+
+
+class DualTransformer2DModel(nn.Module):
+    """
+    Dual transformer wrapper that combines two `Transformer2DModel`s for mixed inference.
+
+    Parameters:
+        num_attention_heads (`int`, *optional*, defaults to 16): The number of heads to use for multi-head attention.
+        attention_head_dim (`int`, *optional*, defaults to 88): The number of channels in each head.
+        in_channels (`int`, *optional*):
+            Pass if the input is continuous. The number of channels in the input and output.
+        num_layers (`int`, *optional*, defaults to 1): The number of layers of Transformer blocks to use.
+        dropout (`float`, *optional*, defaults to 0.1): The dropout probability to use.
+        cross_attention_dim (`int`, *optional*): The number of encoder_hidden_states dimensions to use.
+        sample_size (`int`, *optional*): Pass if the input is discrete. The width of the latent images.
+            Note that this is fixed at training time as it is used for learning a number of position embeddings. See
+            `ImagePositionalEmbeddings`.
+        num_vector_embeds (`int`, *optional*):
+            Pass if the input is discrete. The number of classes of the vector embeddings of the latent pixels.
+            Includes the class for the masked latent pixel.
+        activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to be used in feed-forward.
+        num_embeds_ada_norm ( `int`, *optional*): Pass if at least one of the norm_layers is `AdaLayerNorm`.
+            The number of diffusion steps used during training. Note that this is fixed at training time as it is used
+            to learn a number of embeddings that are added to the hidden states. During inference, you can denoise for
+            up to but not more than steps than `num_embeds_ada_norm`.
+        attention_bias (`bool`, *optional*):
+            Configure if the TransformerBlocks' attention should contain a bias parameter.
+    """
+
+    def __init__(
+        self,
+        num_attention_heads: int = 16,
+        attention_head_dim: int = 88,
+        in_channels: Optional[int] = None,
+        num_layers: int = 1,
+        dropout: float = 0.0,
+        norm_num_groups: int = 32,
+        cross_attention_dim: Optional[int] = None,
+        attention_bias: bool = False,
+        sample_size: Optional[int] = None,
+        num_vector_embeds: Optional[int] = None,
+        activation_fn: str = "geglu",
+        num_embeds_ada_norm: Optional[int] = None,
+    ):
+        super().__init__()
+        self.transformers = nn.ModuleList(
+            [
+                Transformer2DModel(
+                    num_attention_heads=num_attention_heads,
+                    attention_head_dim=attention_head_dim,
+                    in_channels=in_channels,
+                    num_layers=num_layers,
+                    dropout=dropout,
+                    norm_num_groups=norm_num_groups,
+                    cross_attention_dim=cross_attention_dim,
+                    attention_bias=attention_bias,
+                    sample_size=sample_size,
+                    num_vector_embeds=num_vector_embeds,
+                    activation_fn=activation_fn,
+                    num_embeds_ada_norm=num_embeds_ada_norm,
+                )
+                for _ in range(2)
+            ]
+        )
+
+        # Variables that can be set by a pipeline:
+
+        # The ratio of transformer1 to transformer2's output states to be combined during inference
+        self.mix_ratio = 0.5
+
+        # The shape of `encoder_hidden_states` is expected to be
+        # `(batch_size, condition_lengths[0]+condition_lengths[1], num_features)`
+        self.condition_lengths = [77, 257]
+
+        # Which transformer to use to encode which condition.
+        # E.g. `(1, 0)` means that we'll use `transformers[1](conditions[0])` and `transformers[0](conditions[1])`
+        self.transformer_index_for_condition = [1, 0]
+
+    def forward(
+        self,
+        hidden_states,
+        encoder_hidden_states,
+        timestep=None,
+        attention_mask=None,
+        cross_attention_kwargs=None,
+        return_dict: bool = True,
+    ):
+        """
+        Args:
+            hidden_states ( When discrete, `torch.LongTensor` of shape `(batch size, num latent pixels)`.
+                When continuous, `torch.FloatTensor` of shape `(batch size, channel, height, width)`): Input
+                hidden_states.
+            encoder_hidden_states ( `torch.LongTensor` of shape `(batch size, encoder_hidden_states dim)`, *optional*):
+                Conditional embeddings for cross attention layer. If not given, cross-attention defaults to
+                self-attention.
+            timestep ( `torch.long`, *optional*):
+                Optional timestep to be applied as an embedding in AdaLayerNorm's. Used to indicate denoising step.
+            attention_mask (`torch.FloatTensor`, *optional*):
+                Optional attention mask to be applied in Attention.
+            cross_attention_kwargs (`dict`, *optional*):
+                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
+                `self.processor` in
+                [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
+            return_dict (`bool`, *optional*, defaults to `True`):
+                Whether or not to return a [`models.unets.unet_2d_condition.UNet2DConditionOutput`] instead of a plain tuple.
+
+        Returns:
+            [`~models.transformer_2d.Transformer2DModelOutput`] or `tuple`:
+            [`~models.transformer_2d.Transformer2DModelOutput`] if `return_dict` is True, otherwise a `tuple`. When
+            returning a tuple, the first element is the sample tensor.
+        """
+        input_states = hidden_states
+
+        encoded_states = []
+        tokens_start = 0
+        # attention_mask is not used yet
+        for i in range(2):
+            # for each of the two transformers, pass the corresponding condition tokens
+            condition_state = encoder_hidden_states[:, tokens_start : tokens_start + self.condition_lengths[i]]
+            transformer_index = self.transformer_index_for_condition[i]
+            encoded_state = self.transformers[transformer_index](
+                input_states,
+                encoder_hidden_states=condition_state,
+                timestep=timestep,
+                cross_attention_kwargs=cross_attention_kwargs,
+                return_dict=False,
+            )[0]
+            encoded_states.append(encoded_state - input_states)
+            tokens_start += self.condition_lengths[i]
+
+        output_states = encoded_states[0] * self.mix_ratio + encoded_states[1] * (1 - self.mix_ratio)
+        output_states = output_states + input_states
+
+        if not return_dict:
+            return (output_states,)
+
+        return Transformer2DModelOutput(sample=output_states)