Datasets:

zai-org
/

RPC-Bench

@@ -1387,3 +1387,323 @@ parse/dev/Jbdc0vTOcol/Jbdc0vTOcol_origin.pdf filter=lfs diff=lfs merge=lfs -text
 parse/dev/fB0hRu9GZUS/fB0hRu9GZUS_layout.pdf filter=lfs diff=lfs merge=lfs -text
 parse/dev/0xiJLKH-ufZ/0xiJLKH-ufZ_origin.pdf filter=lfs diff=lfs merge=lfs -text
 parse/dev/bzs4uPLXvi/bzs4uPLXvi_span.pdf filter=lfs diff=lfs merge=lfs -text

 parse/dev/fB0hRu9GZUS/fB0hRu9GZUS_layout.pdf filter=lfs diff=lfs merge=lfs -text
 parse/dev/0xiJLKH-ufZ/0xiJLKH-ufZ_origin.pdf filter=lfs diff=lfs merge=lfs -text
 parse/dev/bzs4uPLXvi/bzs4uPLXvi_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/UKd6dpVGdu/UKd6dpVGdu_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/NHeAUKlTO8/NHeAUKlTO8_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/tGHi1HFNBx1/tGHi1HFNBx1_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/tGHi1HFNBx1/tGHi1HFNBx1_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Fkckkr3ya8/Fkckkr3ya8_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/tGHi1HFNBx1/tGHi1HFNBx1_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/WcZUevpX3H3/WcZUevpX3H3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/w1UbdvWH_R3/w1UbdvWH_R3_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/w1UbdvWH_R3/w1UbdvWH_R3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/w1UbdvWH_R3/w1UbdvWH_R3_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/WcZUevpX3H3/WcZUevpX3H3_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Fkckkr3ya8/Fkckkr3ya8_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Fkckkr3ya8/Fkckkr3ya8_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/WcZUevpX3H3/WcZUevpX3H3_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/o4uFFg9_TpV/o4uFFg9_TpV_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Pyd6Rh9r1OT/Pyd6Rh9r1OT_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Pyd6Rh9r1OT/Pyd6Rh9r1OT_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Pyd6Rh9r1OT/Pyd6Rh9r1OT_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rwE8SshAlxw/rwE8SshAlxw_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rwE8SshAlxw/rwE8SshAlxw_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/SF9o3-yP1WR/SF9o3-yP1WR_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iAWNOXfLz0/iAWNOXfLz0_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/voV_TRqcWh/voV_TRqcWh_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/voV_TRqcWh/voV_TRqcWh_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/SF9o3-yP1WR/SF9o3-yP1WR_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/SF9o3-yP1WR/SF9o3-yP1WR_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rwE8SshAlxw/rwE8SshAlxw_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iAWNOXfLz0/iAWNOXfLz0_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/kxXvopt9pWK/kxXvopt9pWK_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/voV_TRqcWh/voV_TRqcWh_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iAWNOXfLz0/iAWNOXfLz0_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/kxXvopt9pWK/kxXvopt9pWK_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/o4uFFg9_TpV/o4uFFg9_TpV_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/o4uFFg9_TpV/o4uFFg9_TpV_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aD7uesX1GF_/aD7uesX1GF__layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/kxXvopt9pWK/kxXvopt9pWK_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aD7uesX1GF_/aD7uesX1GF__origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aD7uesX1GF_/aD7uesX1GF__span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/EbMuimAbPbs/EbMuimAbPbs_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/EbMuimAbPbs/EbMuimAbPbs_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iEvAf8i6JjO/iEvAf8i6JjO_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/EbMuimAbPbs/EbMuimAbPbs_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/HtqnVSCj3q/HtqnVSCj3q_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iEvAf8i6JjO/iEvAf8i6JjO_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/HtqnVSCj3q/HtqnVSCj3q_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/mxzIrQIOGIK/mxzIrQIOGIK_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iEvAf8i6JjO/iEvAf8i6JjO_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/HtqnVSCj3q/HtqnVSCj3q_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/mxzIrQIOGIK/mxzIrQIOGIK_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/FKXVK9dyMM/FKXVK9dyMM_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/mxzIrQIOGIK/mxzIrQIOGIK_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/FKXVK9dyMM/FKXVK9dyMM_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/FKXVK9dyMM/FKXVK9dyMM_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CZZFRxbOLC/CZZFRxbOLC_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/9rKTy4oZAQt/9rKTy4oZAQt_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/9rKTy4oZAQt/9rKTy4oZAQt_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/lYNSvp51a7/lYNSvp51a7_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/pfNyExj7z2/pfNyExj7z2_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/kTcRljax0x9/kTcRljax0x9_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CZZFRxbOLC/CZZFRxbOLC_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/lYNSvp51a7/lYNSvp51a7_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/kTcRljax0x9/kTcRljax0x9_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/9rKTy4oZAQt/9rKTy4oZAQt_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/kTcRljax0x9/kTcRljax0x9_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/pfNyExj7z2/pfNyExj7z2_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CZZFRxbOLC/CZZFRxbOLC_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/pfNyExj7z2/pfNyExj7z2_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/_XNtisL32jv/_XNtisL32jv_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/_XNtisL32jv/_XNtisL32jv_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MAMOi89bOL/MAMOi89bOL_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/lYNSvp51a7/lYNSvp51a7_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MAMOi89bOL/MAMOi89bOL_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/_XNtisL32jv/_XNtisL32jv_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MAMOi89bOL/MAMOi89bOL_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/DAxQXzdq8SF/DAxQXzdq8SF_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iC4UHbQ01Mp/iC4UHbQ01Mp_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3FvF1db-bKT/3FvF1db-bKT_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/T8wHz4rnuGL/T8wHz4rnuGL_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/XSEBx0iSjFQ/XSEBx0iSjFQ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iC4UHbQ01Mp/iC4UHbQ01Mp_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2hMEdc35xZ6/2hMEdc35xZ6_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2hMEdc35xZ6/2hMEdc35xZ6_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/jQgsZDspz5h/jQgsZDspz5h_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/jQgsZDspz5h/jQgsZDspz5h_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2hMEdc35xZ6/2hMEdc35xZ6_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ex60CCi5GS/ex60CCi5GS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iC4UHbQ01Mp/iC4UHbQ01Mp_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/T8wHz4rnuGL/T8wHz4rnuGL_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/jQgsZDspz5h/jQgsZDspz5h_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ex60CCi5GS/ex60CCi5GS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ex60CCi5GS/ex60CCi5GS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/HjwK-Tc_Bc/HjwK-Tc_Bc_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/xkjqJYqRJy/xkjqJYqRJy_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/HjwK-Tc_Bc/HjwK-Tc_Bc_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/xkjqJYqRJy/xkjqJYqRJy_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/xkjqJYqRJy/xkjqJYqRJy_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/HjwK-Tc_Bc/HjwK-Tc_Bc_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/uy602F8cTrh/uy602F8cTrh_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/uy602F8cTrh/uy602F8cTrh_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/uy602F8cTrh/uy602F8cTrh_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/tjFaqsSK2I3/tjFaqsSK2I3_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/tjFaqsSK2I3/tjFaqsSK2I3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/89ia77nZ8u/89ia77nZ8u_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/lq62uWRJjiY/lq62uWRJjiY_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2nJdh_C-UWe/2nJdh_C-UWe_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ebSOK1nV2r/ebSOK1nV2r_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ebSOK1nV2r/ebSOK1nV2r_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/tjFaqsSK2I3/tjFaqsSK2I3_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/89ia77nZ8u/89ia77nZ8u_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/89ia77nZ8u/89ia77nZ8u_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/lq62uWRJjiY/lq62uWRJjiY_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ebSOK1nV2r/ebSOK1nV2r_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/iBBcRUlOAPR/iBBcRUlOAPR_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/lq62uWRJjiY/lq62uWRJjiY_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IFXTZERXdM7/IFXTZERXdM7_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/qY1hlv7gwg/qY1hlv7gwg_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/uytgM9N0vlR/uytgM9N0vlR_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/uytgM9N0vlR/uytgM9N0vlR_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/uytgM9N0vlR/uytgM9N0vlR_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/VOstHxDdsN/VOstHxDdsN_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/td6xbEOPLr/td6xbEOPLr_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aBsCjcPu_tE/aBsCjcPu_tE_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/nVV6S2sb_UL/nVV6S2sb_UL_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/_keb_XuP5oI/_keb_XuP5oI_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/VOstHxDdsN/VOstHxDdsN_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aBsCjcPu_tE/aBsCjcPu_tE_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aBsCjcPu_tE/aBsCjcPu_tE_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/A1yGs_SWiIi/A1yGs_SWiIi_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/_keb_XuP5oI/_keb_XuP5oI_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/A1yGs_SWiIi/A1yGs_SWiIi_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ek9a0qIafW/ek9a0qIafW_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/VOstHxDdsN/VOstHxDdsN_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/A1yGs_SWiIi/A1yGs_SWiIi_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/_keb_XuP5oI/_keb_XuP5oI_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/nVV6S2sb_UL/nVV6S2sb_UL_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rB6TpjAuSRy/rB6TpjAuSRy_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ek9a0qIafW/ek9a0qIafW_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rB6TpjAuSRy/rB6TpjAuSRy_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ek9a0qIafW/ek9a0qIafW_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rB6TpjAuSRy/rB6TpjAuSRy_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/nId8ZtIXub/nId8ZtIXub_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/nVV6S2sb_UL/nVV6S2sb_UL_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ppJuFSOAnM/ppJuFSOAnM_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ppJuFSOAnM/ppJuFSOAnM_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ppJuFSOAnM/ppJuFSOAnM_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/6dlC7E1H_9/6dlC7E1H_9_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/LSKlp_aceOC/LSKlp_aceOC_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/nId8ZtIXub/nId8ZtIXub_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/LSKlp_aceOC/LSKlp_aceOC_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/LSKlp_aceOC/LSKlp_aceOC_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/6dlC7E1H_9/6dlC7E1H_9_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/6dlC7E1H_9/6dlC7E1H_9_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IJNDyqdRF0m/IJNDyqdRF0m_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/6HN7LHyzGgC/6HN7LHyzGgC_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/O476oWmiNNp/O476oWmiNNp_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/nId8ZtIXub/nId8ZtIXub_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rTvH1_SRyXs/rTvH1_SRyXs_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/AOKU4nRw1W/AOKU4nRw1W_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/0gouO5saq6K/0gouO5saq6K_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/0gouO5saq6K/0gouO5saq6K_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rTvH1_SRyXs/rTvH1_SRyXs_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/DAxQXzdq8SF/DAxQXzdq8SF_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ePhEbo039l/ePhEbo039l_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/9XFSbDPmdW/9XFSbDPmdW_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ePhEbo039l/ePhEbo039l_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/9XFSbDPmdW/9XFSbDPmdW_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ePhEbo039l/ePhEbo039l_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/9XFSbDPmdW/9XFSbDPmdW_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/DAxQXzdq8SF/DAxQXzdq8SF_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MbCAOMGsZXC/MbCAOMGsZXC_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/gJcEM8sxHK/gJcEM8sxHK_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MbCAOMGsZXC/MbCAOMGsZXC_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/gJcEM8sxHK/gJcEM8sxHK_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/gJcEM8sxHK/gJcEM8sxHK_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MbCAOMGsZXC/MbCAOMGsZXC_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CAjxVodl_v/CAjxVodl_v_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CAjxVodl_v/CAjxVodl_v_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CAjxVodl_v/CAjxVodl_v_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/wtqb7pNL4e/wtqb7pNL4e_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/wtqb7pNL4e/wtqb7pNL4e_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/wtqb7pNL4e/wtqb7pNL4e_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/eHrqmewX1B-/eHrqmewX1B-_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/eHrqmewX1B-/eHrqmewX1B-_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/B4tkwuzeiY/B4tkwuzeiY_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/VNqaB1g9393/VNqaB1g9393_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/JXhROKNZzOc/JXhROKNZzOc_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/B4tkwuzeiY/B4tkwuzeiY_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/eHrqmewX1B-/eHrqmewX1B-_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/B4tkwuzeiY/B4tkwuzeiY_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/JXhROKNZzOc/JXhROKNZzOc_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/RYTBAtyXqJ/RYTBAtyXqJ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/JXhROKNZzOc/JXhROKNZzOc_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/qY1hlv7gwg/qY1hlv7gwg_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/VNqaB1g9393/VNqaB1g9393_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IFXTZERXdM7/IFXTZERXdM7_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/RYTBAtyXqJ/RYTBAtyXqJ_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/RYTBAtyXqJ/RYTBAtyXqJ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/qY1hlv7gwg/qY1hlv7gwg_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/VNqaB1g9393/VNqaB1g9393_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IFXTZERXdM7/IFXTZERXdM7_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rTvH1_SRyXs/rTvH1_SRyXs_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3tYvDb4dwab/3tYvDb4dwab_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/AOKU4nRw1W/AOKU4nRw1W_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/AOKU4nRw1W/AOKU4nRw1W_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3tYvDb4dwab/3tYvDb4dwab_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/O476oWmiNNp/O476oWmiNNp_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3tYvDb4dwab/3tYvDb4dwab_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/O476oWmiNNp/O476oWmiNNp_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/6HN7LHyzGgC/6HN7LHyzGgC_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/6HN7LHyzGgC/6HN7LHyzGgC_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rY2wXCSruO/rY2wXCSruO_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/0gouO5saq6K/0gouO5saq6K_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IJNDyqdRF0m/IJNDyqdRF0m_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IJNDyqdRF0m/IJNDyqdRF0m_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CbsJ53LdKc/CbsJ53LdKc_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rY2wXCSruO/rY2wXCSruO_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CbsJ53LdKc/CbsJ53LdKc_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rY2wXCSruO/rY2wXCSruO_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/x1FgW3vSM6/x1FgW3vSM6_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/x1FgW3vSM6/x1FgW3vSM6_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/x1FgW3vSM6/x1FgW3vSM6_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/e2TBb5y0yFf/e2TBb5y0yFf_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CbsJ53LdKc/CbsJ53LdKc_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/e2TBb5y0yFf/e2TBb5y0yFf_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/-70L8lpp9DF/-70L8lpp9DF_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2EufPS5ABlJ/2EufPS5ABlJ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/e2TBb5y0yFf/e2TBb5y0yFf_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2EufPS5ABlJ/2EufPS5ABlJ_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/-70L8lpp9DF/-70L8lpp9DF_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/K3BMejPSyQ/K3BMejPSyQ_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/-70L8lpp9DF/-70L8lpp9DF_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/JvIFpZOjLF4/JvIFpZOjLF4_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2EufPS5ABlJ/2EufPS5ABlJ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/gEZrGCozdqR/gEZrGCozdqR_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/gEZrGCozdqR/gEZrGCozdqR_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CuV_qYkmKb3/CuV_qYkmKb3_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CuV_qYkmKb3/CuV_qYkmKb3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/K3BMejPSyQ/K3BMejPSyQ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/BryMFPQ4L6/BryMFPQ4L6_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/JvIFpZOjLF4/JvIFpZOjLF4_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/JvIFpZOjLF4/JvIFpZOjLF4_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/td6xbEOPLr/td6xbEOPLr_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CuV_qYkmKb3/CuV_qYkmKb3_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/K3BMejPSyQ/K3BMejPSyQ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/gEZrGCozdqR/gEZrGCozdqR_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/5JdLZg346Lw/5JdLZg346Lw_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/5JdLZg346Lw/5JdLZg346Lw_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/BryMFPQ4L6/BryMFPQ4L6_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/BryMFPQ4L6/BryMFPQ4L6_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rFbR4Fv-D6-/rFbR4Fv-D6-_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/5JdLZg346Lw/5JdLZg346Lw_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rFbR4Fv-D6-/rFbR4Fv-D6-_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/rFbR4Fv-D6-/rFbR4Fv-D6-_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CzceR82CYc/CzceR82CYc_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2-REuflJDT/2-REuflJDT_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/DhmYYrH_M3m/DhmYYrH_M3m_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CzceR82CYc/CzceR82CYc_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/td6xbEOPLr/td6xbEOPLr_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/-Aw0rrrPUF/-Aw0rrrPUF_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CzceR82CYc/CzceR82CYc_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/upJ3vrFKaL/upJ3vrFKaL_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2-REuflJDT/2-REuflJDT_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3s9IrEsjLyk/3s9IrEsjLyk_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MR7XubKUFB/MR7XubKUFB_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/A4fSkNAs6E1/A4fSkNAs6E1_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3s9IrEsjLyk/3s9IrEsjLyk_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/-Aw0rrrPUF/-Aw0rrrPUF_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/-Aw0rrrPUF/-Aw0rrrPUF_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/A4fSkNAs6E1/A4fSkNAs6E1_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/2-REuflJDT/2-REuflJDT_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/A4fSkNAs6E1/A4fSkNAs6E1_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/DhmYYrH_M3m/DhmYYrH_M3m_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3s9IrEsjLyk/3s9IrEsjLyk_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/DhmYYrH_M3m/DhmYYrH_M3m_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MR7XubKUFB/MR7XubKUFB_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/mTiHLHu3sP/mTiHLHu3sP_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/T0GpzBQ1Fg6/T0GpzBQ1Fg6_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/MR7XubKUFB/MR7XubKUFB_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/mTiHLHu3sP/mTiHLHu3sP_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/mTiHLHu3sP/mTiHLHu3sP_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/T0GpzBQ1Fg6/T0GpzBQ1Fg6_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/upJ3vrFKaL/upJ3vrFKaL_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/upJ3vrFKaL/upJ3vrFKaL_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IajGRJuM7D3/IajGRJuM7D3_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/T0GpzBQ1Fg6/T0GpzBQ1Fg6_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/RKiWwhocuiU/RKiWwhocuiU_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/RKiWwhocuiU/RKiWwhocuiU_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IajGRJuM7D3/IajGRJuM7D3_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/RKiWwhocuiU/RKiWwhocuiU_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/68n2s9ZJWF8/68n2s9ZJWF8_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/8aHzds2uUyB/8aHzds2uUyB_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/IajGRJuM7D3/IajGRJuM7D3_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CQsmMYmlP5T/CQsmMYmlP5T_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/8aHzds2uUyB/8aHzds2uUyB_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/hQwb-lbM6EL/hQwb-lbM6EL_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/68n2s9ZJWF8/68n2s9ZJWF8_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/68n2s9ZJWF8/68n2s9ZJWF8_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/8aHzds2uUyB/8aHzds2uUyB_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/FWMQYjFso-a/FWMQYjFso-a_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/bdHkMjBJG_w/bdHkMjBJG_w_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/xT5rDp5VqKO/xT5rDp5VqKO_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/xT5rDp5VqKO/xT5rDp5VqKO_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/hQwb-lbM6EL/hQwb-lbM6EL_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/FWMQYjFso-a/FWMQYjFso-a_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/xT5rDp5VqKO/xT5rDp5VqKO_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/hQwb-lbM6EL/hQwb-lbM6EL_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CQsmMYmlP5T/CQsmMYmlP5T_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/FWMQYjFso-a/FWMQYjFso-a_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aa8KsqfTPa/aa8KsqfTPa_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/bdHkMjBJG_w/bdHkMjBJG_w_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/CQsmMYmlP5T/CQsmMYmlP5T_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/bdHkMjBJG_w/bdHkMjBJG_w_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aa8KsqfTPa/aa8KsqfTPa_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/aa8KsqfTPa/aa8KsqfTPa_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ZBESeIUB5k/ZBESeIUB5k_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/ECvgmYVyeUz/ECvgmYVyeUz_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/c5Inzw6giM/c5Inzw6giM_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Uynr3iPhksa/Uynr3iPhksa_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/401LFvBGIb/401LFvBGIb_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/LPB2BFZvncQ/LPB2BFZvncQ_origin.pdf filter=lfs diff=lfs merge=lfs -text

parse/dev/-70L8lpp9DF/-70L8lpp9DF_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:ed434ba1a776524374390bf161a3644ca7ef69e23f782be77092cd3df2425aaa
+size 1243720

parse/dev/-70L8lpp9DF/-70L8lpp9DF_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:b1cf3b4238f530b1cd1bf46189ea81fa8af8fdb713d0c2db1e667170ec14ee61
+size 684373

parse/dev/-70L8lpp9DF/-70L8lpp9DF_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:5014a40c5b5a701af22942cce503fc64d91befbe2ce40d48328f4f52d43c37c5
+size 1279245

parse/dev/-Aw0rrrPUF/-Aw0rrrPUF_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:468929add971a259767ea2d643eb0a2f4d4e9b2f3f80aefa1b872ad799640d6c
+size 5121505

parse/dev/-Aw0rrrPUF/-Aw0rrrPUF_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:95b7e5d1412f463ee39cffc4024178a801e70972a38e90f98dabfe00d527340b
+size 4599196

parse/dev/-Aw0rrrPUF/-Aw0rrrPUF_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:34c06264356eb09ab3c979ba0075933c074d66168b3eb2fa621cc242c97a6feb
+size 5112201

parse/dev/0gouO5saq6K/0gouO5saq6K_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:f17fe68e47cd77d394f822b1b32f48d75c82d4cdd8b41574fd63bfca294d01e1
+size 1180251

parse/dev/0gouO5saq6K/0gouO5saq6K_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:479a42d9bb1fd66dce1a41218f947bceb77bc07154a6f9072837ea10c3f62ee8
+size 1013109

parse/dev/0gouO5saq6K/0gouO5saq6K_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:098bbefd86f5a26eb4d058d4a17b9fd894ee8fa7815648374532b5b01bcb730d
+size 1187332

parse/dev/1PL1NIMMrw/1PL1NIMMrw_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/dev/1qvx610Cu7/1qvx610Cu7.md ADDED Viewed

	@@ -0,0 +1,217 @@

+# Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation
+Jiawei Liu ∗ Chunqiu Steven Xia ∗ Yuyao Wang Lingming Zhang
+University of Illinois Urbana-Champaign Nanjing University
+{jiawei6, chunqiu2, lingming}@illinois.edu yuyao6@outlook.com
+# Abstract
+Program synthesis has been long studied with recent approaches focused on directly using the power of Large Language Models (LLMs) to generate code. Programming benchmarks, with curated synthesis problems and test-cases, are used to measure the performance of various LLMs on code synthesis. However, these test-cases can be limited in both quantity and quality for fully assessing the functional correctness of the generated code. Such limitation in the existing benchmarks begs the following question: In the era of LLMs, is the code generated really correct? To answer this, we propose EvalPlus – a code synthesis evaluation framework to rigorously benchmark the functional correctness of LLM-synthesized code. EvalPlus augments a given evaluation dataset with large amounts of test-cases newly produced by an automatic test input generator, powered by both LLM- and mutation-based strategies. While EvalPlus is general, we extend the test-cases of the popular HUMANEVAL benchmark by $8 0 \times$ to build HUMANEVAL+. Our extensive evaluation across 26 popular LLMs (e.g., GPT-4 and ChatGPT) demonstrates that HUMANEVAL+ is able to catch significant amounts of previously undetected wrong code synthesized by LLMs, reducing the pass $@ k$ by up-to $1 9 . 3 \substack { - 2 8 . 9 \% }$ . We also surprisingly found that test insufficiency can lead to mis-ranking. For example, both WizardCoder-CodeLlama and Phind-CodeLlama now outperform ChatGPT on HUMANEVAL+, while none of them could on HUMANEVAL. Our work not only indicates that prior popular code synthesis evaluation results do not accurately reflect the true performance of LLMs for code synthesis, but also opens up a new direction to improve such programming benchmarks through automated testing. We have open-sourced our tools, enhanced datasets as well as all LLM-generated code at https://github.com/evalplus/evalplus to facilitate and accelerate future LLM-for-code research.
+# 1 Introduction
+Automatically generating programs that accurately correspond to user intents is a long-standing challenge in computer science known as program synthesis [21]. In the past few decades, classical program synthesis techniques have been developed, including deductive synthesis [19, 39, 62], inductive synthesis [20, 58] and neural-guided synthesis [29]. More recently, with the advent of Large Language Models [61, 6] (LLMs) and the abundance of open codebase, researchers have been focusing on applying LLMs for direct code generation. LLMs like CODEX [11] and CodeGen [46] perform code generation by autoregressively predicting the next token given previous context, in the form of function signature and docstring that denote the desired program functionality. The generated code snippet is then combined with the context to form a complete function that aligns with the user intent. Leveraging both natural language understanding and generative power, LLMs have demonstrated impressive performance in code synthesis [3, 11].
+![](images/3123815fc6ee764f610b9ae26921911c0080b9bf9a5fda7fb8f6bb0ec472825d.jpg)
+Figure 1: Exemplary wrong code synthesized by ChatGPT for HUMANEVAL #58.
+The primary concern when it comes to LLM-generated code is correctness. Because two dramatically different code snippets can be semantically equivalent, classic NLP metrics like BLEU score [50] are no longer reliable in the context of program synthesis. Ideally, we would like to formally verify the correctness of LLM-provided solutions for any input, but verifying domain-specific problems through methods such as translation validation [36, 44, 4] is already challenging enough, let alone building a general verifier with absolute certainty to prove arbitrary problems, including those in code benchmarks. As such, existing code benchmarks (e.g., HUMANEVAL [11]) heavily rely on manually constructed test-cases to evaluate LLM solutions. However, these tests often fall short in capturing all possible scenarios, as crafting high-quality tests is laborious. Consequently, we argue that current programming benchmarks are inadequate for assessing the actual correctness of LLM-generated code, leading to false confidence in the results. Specifically, we have identified the following common limitations in existing LLM-for-code benchmarks:
+• Insufficient testing. Current programming benchmarks often only include on average less than 10 tests for each coding problem. Furthermore, these tests are relatively too simple to fully explore the functionality of the code or corner cases. Figure 1 shows an incorrect code sample synthesized by ChatGPT [48] to return the sorted unique common elements from two lists. At first glance, the function looks correct and computes the desired output when using the base test inputs from HUMANEVAL. However, in the return statement, it incorrectly converts the intermediate list to a set which no longer preserves the order of the sorted list. This example shows that a logically flawed solution can still pass all simple tests and be misconsidered as correct due to testing inadequacy. Imprecise problem description. The input for code generation includes natural language descriptions in addition to the function signature. These task descriptions in existing benchmarks are oftentimes too vague to fully clarify the expected program behaviors. For example, the input docstring may not specify the expected input domain (e.g., only positive integers) or how the function should handle exceptions. As a result, such programming problems can be interpreted differently by LLMs against the actual tests, leading to capable LLMs misjudged as incapable.
+These limitations are common across many popular code generation benchmarks [11, 3, 33]. This not only questions the validity of the impressive performance claimed by prior work but also sets a challenge on how to properly evaluate the LLM coders. In this paper, we aim to address this fundamental evaluation challenge and ask the introspective question: Is the code generated by LLMs really correct?
+Our proposal. In this work, we set out to answer the important question and evaluate the evaluation dataset. Consequently, we build EvalPlus – an evaluation framework to improve existing code benchmarks in order to precisely evaluate the functional correctness of LLM-generated code. At the heart of EvalPlus is an automatic test input generation engine which augments existing code benchmarks by generating interesting test inputs to fully exercise the code solution and check its functional correctness by cross-checking the ground-truth implementation. Specifically, EvalPlus adopts both LLM- and mutation-based [57, 74, 47] methods to automatically generate and diversify additional test inputs. EvalPlus first uses ChatGPT [48] to generate a set of high-quality seed inputs that aim to test difficult corner cases and functionalities of the program within the valid input structure. Using these high-quality seed inputs, EvalPlus then performs type-aware mutation to efficiently generate a large number of additional test inputs. These newly generated test inputs are then used to evaluate the LLM-generated code through differential testing [40] against the ground-truth implementation. Furthermore, as an option to speed up evaluation, EvalPlus also builds minimal test-suites by only including the most valuable test-cases, which are selected by running a greedy set cover algorithm to preserve the same code coverage [24], mutation analysis [7] as well as empirical LLM sample killings.
+![](images/db8c3d3ffdb7024ce0d9bfd7ea7adb89d8b708b14a9e41e575743b2eb90d60f0.jpg)
+Figure 2: Overview of EvalPlus
+Contribution. Our work revisited and proposed to automatically improve code benchmarks for LLMs:
+• Study: We are the first to study the test inadequacy problem in current programming benchmarks which can lead to largely over-approximated functional correctness. Our study also opens up a new research direction for precisely and rigorously evaluating LLM-synthesized code.
+• Approach: We propose EvalPlus – an evaluation framework to reveal the real correctness of LLM-synthesized code. The test-case generation approach of EvalPlus combines the emerging LLM-based and traditional mutation-based test input generation. It first uses LLM-based strategy to bootstrap the test generator with high-quality seed inputs and then further extends large amounts of inputs via type-aware mutation. We then optionally “distill” the generated tests to a much smaller yet almost equivalently effective test-suite via greedy set covering. We also propose to annotate each programming tasks using program contracts to filter out invalid inputs.
+• Results: EvalPlus extends the popular HUMANEVAL benchmark to create HUMANEVAL+, improving the test-case scale by $8 0 \times$ . Through test-suite reduction, we also produce HUMANEVAL+-MINI which distills HUMANEVAL+ tests by $4 7 \times$ while still achieving a similar level of testing effectiveness. Our extensive evaluation over 26 popular LLMs surprisingly finds that the pass $@ k$ on the new dataset is up-to $1 9 . 3 \substack { - 2 8 . 9 \% }$ (for different $k s$ ) lower than the base HUMANEVAL, showing that testing insufficiency can largely affect the result analysis for almost all recent work on LLM-based code generation. Meanwhile, on the original HUMANEVAL both of the 34B WizardCoder-CodeLlama [38] and Phind-CodeLlama [52] models are deemed to be no better than ChatGPT, while HUMANEVAL+ corrected the ranking and shows that the two open-source models are actually better. Additionally, we even found that the ground-truth solutions of HUMANEVAL can be erroneous, further calling into question the quality of code synthesis benchmarks.
+# 2 Approach
+Figure 2 shows the overview of EvalPlus. We first take in as input the original dataset containing the ground-truth implementation as well as the base test inputs. EvalPlus starts with constructing a prompt using the original ground-truth, exemplary test inputs as demonstration, and a specialized instruction to query ChatGPT and generate a set of high-quality seed inputs. ChatGPT, by following base input formats and inspecting the ground-truth solution, can serve as a vehicle to generate valid yet rigorous test inputs. Starting from these seed inputs, we then perform type-aware mutation to quickly generate numerous new inputs together with seed inputs to extensively evaluate the functional correctness of LLM-generated code. We use differential testing [40] as the oracle to cross-check the output of the ground-truth and LLM-generated solution. As an option to speed up evaluation, EvalPlus runs set covering to minimize the generated test-suite while preserving the same level of testing effectiveness. As the final output, EvalPlus obtains a augmented benchmark using the generated high-quality test inputs to fully evaluate the functional correctness of LLM-synthesized code.
+Table 1: List of basic type-aware mutations over input $x$ .
+<table><tr><td>Type</td><td>Mutation</td><td>Type</td><td>Mutation</td></tr><tr><td>int|float</td><td>Returns x±1</td><td>List</td><td>Remove/repeat a random item x[i] Insert/replace x[i] with Mutate(x[i])</td></tr><tr><td>bool</td><td>Returns a random boolean</td><td>Tuple</td><td>Returns Tuple(Mutate(List(x)))</td></tr><tr><td>NoneType</td><td>Returns None</td><td>Set</td><td>Returns Set(Mutate(List(x)))</td></tr><tr><td>str</td><td>Remove a sub-string s Repeat a sub-string s Replace s with Mutate(s)</td><td>Dict</td><td>Remove a key-value pair k→ U Update k -→v to k-→Mutate(u) Insert Mutate(k)→Mutate(u)</td></tr></table>
+# 2.1 Automated Test Input Generation
+Seed initialization via ChatGPT. EvalPlus first uses ChatGPT to generate a set of high-quality seed inputs for later mutation. Following Figure 2, we construct a prompt using $( i )$ the ground-truth solution of the problem for ChatGPT to inspect; (ii) a set of test inputs as demonstration; and (iii) an instruction to encourage ChatGPT to come up with interesting inputs. Specifically, each prompt starts with the ground-truth implementation and then randomly sampled test inputs from the existing dataset. We then finalize the prompt with a selected instruction in Figure 2 and query ChatGPT to produce new inputs. EvalPlus aims to leverage the powerful understanding ability of ChatGPT to learn both the valid input formats (e.g., variable types) as well as the desired functionality of the ground-truth solution in order to produce meaningful test inputs to reveal bugs in incorrectly synthesized code. Programs can have their own expected input formats, where invalid inputs should not be passed into the function as they can incur undefined behaviors to create false-positives in differential testing. As such, we filter out any invalid inputs which violate the input precondition required by the ground-truth implementation.
+By using ChatGPT as an automated generation engine, we can generate inputs that are valid even under semantic constraints. For example, a programming problem may require the input to conform to a specific structure (e.g., a palindrome). Such semantic constraints can be extremely difficult for traditional input generators to satisfy. However, ChatGPT is unsuitable for large amounts of automated test generation due to undesired speed and cost of querying such a large model. To address this, we perform type-aware input mutation starting from high-quality seed inputs generated by ChatGPT.
+Type-aware input mutation. We follow a typical mutation-based fuzzing workflow [74, 57] to continuously create inputs: (i) a corpus of seed inputs from ChatGPT are used to initialize the seed pool and bootstrap the generation pipeline; (ii) each time an input (i.e., seed) from the seed pool is randomly selected to be mutated to a new input (i.e., mutant); and (iii) new inputs that comply with the program contract (§2.3) are added to the seed pool and we start over from (ii) to continue the generation process.
+To efficiently create more valid inputs, we leverage type-aware mutation [66] in step (ii) which inspects the data types of the incoming valid seeds and generates new inputs that are structurally similar to the seeds. In Table 1 we illustrate the basic mutations used for different types of inputs. For simple primitive types such as int and float, the mutation is as simple as incrementing/decrementing the value. For compound types and the string type (i.e., str), besides generally removing or repeating existing elements (or sub-strings for str), the elements and sub-strings can be mutated recursively according to their inner types. Such sub-mutants can then be used to replace existing items or add new items in a finer-grain manner. In addition, to alleviate generating inputs that violate subtle semantic constraints, following [23, 34], we additionally apply an ingredient mechanism to collect appeared data fragments and reuse them during mutation. In short, type-aware input mutation builds on the high-quality seed inputs produced by ChatGPT to generate large amounts of test inputs which we use as the final set of extensive test inputs to evaluate LLM-synthesized code.
+# 2.2 Test-Suite Reduction
+While the large number of newly generated tests in EvalPlus are effective in detecting incorrect code, the test execution can be costly. As an option to more efficiently evaluate LLM-generated code, we further investigate test-suite reduction strategies [75, 59], which aim to select a subset of the original test-suite while still maintaining the original test effectiveness. To perform test reduction, it is typically assumed that each test can fulfill a set of testing requirements. The problem can then be formalized as reducing the original test-suite $\tau$ into $\mathcal { T } _ { r e d }$ , such that $\forall r \in \mathcal { R }$ ( $\exists t \in \tau$ , $t$ satisfies $r \implies \exists t ^ { \prime } \in$ $\mathcal { T } _ { r e d } , t ^ { \prime }$ satisfies $r$ ). In other words, any testing requirement $r$ satisfied by the original test-suite should still be satisfied by the reduced one. Finding such minimal representative subset for a given test-suite is equivalent to the set covering problem [17]. To solve this problem effectively, it is crucial to define the testing requirements accurately. In this paper, we focus on the following types of requirements:
+Code coverage: Code coverage [24] measures the amount of code elements (e.g., statements or branches) executed by each test, and has been widely used in practice to measure test effectiveness. In this strategy, following traditional test-suite reduction [53] we leverage the widely used branch coverage as the testing requirement. In other words, the goal of using this metric is to only preserve a minimal subset of tests which can cover the same set of branches as the full tests.
+Mutant killings: Coverage measures the extent to which the code has been executed; however, a high-coverage test-case is not necessarily effective in finding critical defects in its covered code. Consequently, researchers have proposed mutation testing [7] (also known as mutation analysis) to more precisely evaluate test effectiveness. In short, mutation testing applies a set of predefined mutation rules (e.g., changing $" < "$ and $\ " \leq \ " \}$ ) to the program under test (i.e., the ground-truth solutions for this case) to create a large number of artificial buggy programs, each of which is called as a mutant and includes exactly one subtle bug seeded. In this way, the ratio of mutation bugs detected by the tests (also called killed) can be used to assess the test effectiveness. In fact, studies have shown that mutation testing can largely outperform code coverage in test effectiveness evaluation [51]. Following prior work [59], we also leverage the set of mutants killed by each test as our testing requirement. Consequently, the goal is to minimize the number of tests while still being able to detect the same set of mutation bugs.
+LLM sample killings: Different LLMs could fail commonly over certain test-cases. Consequently, besides these theoretical metrics, we also use as a testing requirement by empirically looking at sample killings, i.e., the set of wrong LLM samples that a test-case can detect and falsify. Of course, for a new LLM under evaluation, we do not have any test execution results for its code samples. Therefore, we only use the execution results for samples generated by other LLMs to evaluate test effectiveness for reduction (i.e., leave-one-out cross validation [22]). As such, we minimize the number of tests while making sure that all incorrect samples synthesized by other models can be detected by the reduced test-suite.
+Besides the above three strategies, we also investigate another strategy that merges all three testing requirements for reduction. That is, the goal is to minimize the number of tests while still maintaining the same branch coverage, mutant killing, and incorrect sample detection results.
+# 2.3 Program Input Contracts
+The goal of evaluating code synthesis is to check whether the synthesized code accurately reflects the desired user intent. This is done by using several test inputs and comparing the output of the generated code against that of the ground-truth solution. The prior sections demonstrated how to improve the test inputs used to more rigorously evaluate the synthesized code. However, these user intents (expressed as natural language docstring) can be too vague for LLMs to follow. As such, LLMs might allow for different interpretations of the desired functionality, input formats as well as how to handle corner cases.
+To this end, we adopt a programming by contract [41] philosophy by systematically annotating function pre-conditions in form of code assertions (e.g., assert $\mathbf { n } > 0$ ), to ensure the test inputs for the function are well-formed. The benefits of the contracts are two-fold: $( i )$ they can complement the automatic input generation steps to filter out any generated invalid inputs that violate the contracts. Such ill-formed inputs can incur undefined behaviors which are unreasonable to use for evaluating LLM-synthesized code; and (ii) they can serve as orthogonal descriptors together with the natural language description in the prompt for further clarification.
+Table 2: Overview of EvalPlus-improved benchmarks.
+<table><tr><td rowspan="3"></td><td colspan="4">#Tests</td><td rowspan="3">#Tasks</td></tr><tr><td>Avg.</td><td>Medium</td><td>Min.</td><td>Max.</td></tr><tr><td>HUMANEVAL</td><td>9.6</td><td>7.0</td><td>1</td><td>105²</td><td rowspan="3">164</td></tr><tr><td>HUMANEVAL+</td><td>764.1</td><td>982.5</td><td>12</td><td>1,100</td></tr><tr><td>HUMANEVAL+ -MINI</td><td>16.1</td><td>13.0</td><td>5</td><td>110</td></tr></table>
+# 3 Evaluation
+Setup. Our evaluation focuses on using the unbiased version of $\operatorname { p a s s } @ k$ [11] to accurately assess the functional correctness of LLM-synthesized code. For generalizability, we conducted a comprehensive evaluation over 26 popular and state-of-the-art LLMs and a wide range of temperature settings. Specifically, following prior work [11, 46], for each model we perform: $( i )$ random sampling to generate 200 program samples for each of the four temperature settings $( \{ 0 . 2 , 0 . 4 , 0 . 6 , 0 . \bar { 8 } \} )$ ; and $( i i )$ greedy-search decoding. For random sampling, we show the best-performing pass $@ k$ for each $k \in \mathsf { \bar { \{ 1 , 1 0 , 1 0 0 \} } }$ and its corresponding temperature denoted by $T _ { k } ^ { * }$ . For greedy decoding, we only synthesize one deterministic sample for each task and evaluate its pass rate as pass $@ 1 ^ { \star }$ . By default we evaluate models under both setting $( i )$ and $( i i )$ , except for the two commercial models due to time and cost constraints: GPT-4 is only evaluated under greedy decoding, and ChatGPT is additionally evaluated on 0.8-temperature random sampling.
+While EvalPlus is general, this paper focuses on evaluating its effectiveness on HUMANEVAL [11], one of the most widely-used datasets for code generation3. HUMANEVAL consists of 164 humanwritten programming tasks, each of which provides a Python function signature and a docstring as the input to the LLM. Based on the input, LLMs complete a solution whose functional correctness is judged by a handful of manual test-cases (the first row in Table 2). As such, EvalPlus transforms HUMANEVAL to HUMANEVAL+ by adding $8 0 \times$ unique test-cases and fixing incorrect ground-truth solutions in HUMANEVAL. Specifically, for each task, based on around 30 ChatGPT-generated seed inputs which are produced using 3 separate prompts, we run type-aware mutation to generate 1000 additional inputs using one-hour budget. In HUMANEVAL+, 83 out of the 164 programming tasks are annotated with hand-crafted contracts. Because EvalPlus requires ground-truth solutions to cross-check LLM-generated code, it is crucial to ensure the correctness of the ground-truths. However, by inspecting ground-truths in the original HUMANEVAL, we found over $10 \%$ of them are incorrectly implemented. Therefore, as another contribution we carefully re-implemented and tested all ground-truths for HUMANEVAL+. As an option to speed up evaluation, we build HUMANEVAL+-MINI which is minimized from HUMANEVAL+ (smaller by $4 7 \times$ ) yet preserves similar test effectiveness on the studied models. Lastly, more experimental setups are detailed in Appendix.
+Evaluation of LLMs. Table 3 shows the pass $@ k$ when evaluating LLMs using both the base HUMANEVAL and HUMANEVAL+. We first observe that across all LLMs, models sizes and $k$ values, using HUMANEVAL+, almost all pass $@ k$ results consistently drop compared to using the base HUMANEVAL. Notably, the performance drop is significant with up-to $2 3 . 1 \%$ $( \mathrm { p a s s } @ 1 ^ { \star } )$ / $1 9 . 3 \%$ (pass $@ 1$ ) $/ 2 4 . 9 \%$ (pass $@ 1 0$ ) $/ 2 8 . 9 \%$ (pass $@ 1 0 0 _ { , }$ ) reduction over the evaluated models. Such performance decrease is not only seen in popular open-source LLMs, such as the widely used CodeGen-16B [46] $( 1 8 . 5 \%$ reduction) as well as the emerging CODELLAMA-34B [54] $( 1 7 . 6 \% )$ and StarCoder [13] ( $1 4 . 1 \%$ reduction), but also observed in state-of-the-art commercial ChatGPT $( 1 2 . 6 \%$ reduction) and GPT-4 $2 3 . 1 \%$ reduction) models. Overall, our results overall confirm our hypothesis that the prior evaluation on HUMANEVAL is not robust enough to detect wrong code synthesized by LLMs. Not only are these LLMs widely used for daily programming but they also serve as common reference points for evaluating new code synthesis techniques. As such, evaluating on a more robust benchmark such as HUMANEVAL+ is highly recommended in order to draw precise conclusions.
+Table 3: Evaluating LLMs on HUMANEVAL and HUMANEVAL+. All models, except for INCODER, CodeGen2, StarCoder and SantaCoder which perform infilling, use auto-regressive generation. $k { = } 1 ^ { \star }$ marks pass $@ 1$ done with greedy decoding. $T _ { k } ^ { * }$ denotes the optimal pass $@ k$ temperature.
+<table><tr><td></td><td>Size pass@k</td><td>k=1*</td><td>k=1</td><td>k=10</td><td>k=100</td><td></td><td>T</td><td>T0</td><td>T100</td></tr><tr><td>GPT-4 [49]</td><td>N/A</td><td>base +extra</td><td>88.4 76.2</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Phind-CodeLlama [52]</td><td>34B</td><td>base</td><td>71.3</td><td>71.6</td><td>90.5</td><td>96.2</td><td>2</td><td>.8</td><td>.8</td></tr><tr><td>WizardCoder-CodeLlama [38]</td><td>34B</td><td>+extra base</td><td>67.1 73.2</td><td>67.0 61.6</td><td>85.0 85.2</td><td>92.5 94.5</td><td>2</td><td>.8 .8</td><td>.8 .8</td></tr><tr><td></td><td>N/A</td><td>+extra base</td><td>64.6 73.2 69.4</td><td>54.5</td><td>78.6 88.6</td><td>88.9 94.0</td><td></td><td>.8</td><td>.8</td></tr><tr><td>ChatGPT [48]</td><td>34B</td><td>+extra</td><td>63.4 51.8</td><td>62.5 52.0</td><td>82.1</td><td>91.1</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td rowspan="3">CODELLAMA [54]</td><td rowspan="3">13B</td><td>base +extra</td><td>42.7 43.1</td><td></td><td>82.4</td><td>95.0</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>base</td><td>42.7 44.6</td><td></td><td>73.7 77.6</td><td>89.4</td><td>.4</td><td>.8</td><td>.8</td></tr><tr><td> +extra</td><td>36.6 37.4</td><td>69.4</td><td></td><td>92.7 88.2</td><td>.4</td><td>.8</td><td>.8</td></tr><tr><td></td><td>7B</td><td>base</td><td>37.8</td><td>39.2 69.1</td><td></td><td>89.7</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>StarCoder [13]</td><td>15B</td><td>+extra base</td><td>34.1 34.1</td><td>34.5 32.2</td><td>61.4 56.7</td><td>82.9 84.2</td><td>.2 .2</td><td>.8</td><td>.8 .8</td></tr><tr><td></td><td>16B</td><td>+extra base</td><td>29.3 32.9</td><td>27.8 32.2 56.0</td><td>50.3</td><td>75.4 81.5</td><td>.2 .2</td><td>.8 .6</td><td>.8 .8</td></tr><tr><td rowspan="3">CodeGen [46]</td><td rowspan="2">6B</td><td> +extra</td><td>26.8 29.3</td><td>27.2 48.4</td><td></td><td>71.4 .2</td><td>.2</td><td>.6 .6</td><td>.8 .8</td></tr><tr><td>base +extra</td><td>27.7 25.6</td><td>46.9</td><td></td><td>72.7</td><td>.2</td><td>.6</td><td>.8</td></tr><tr><td>base</td><td></td><td>23.6 18.4</td><td>41.0</td><td>64.6</td><td></td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>CODET5+ [64]</td><td>2B</td><td>+extra</td><td>24.4 20.7</td><td>15.1</td><td>39.8 34.8</td><td>66.8 55.8</td><td>.2</td><td>2</td><td>.8</td></tr><tr><td></td><td>16B</td><td>base +extra</td><td>31.7 26.2</td><td>32.2 27.4</td><td>58.5 51.1</td><td>83.5</td><td>2</td><td>.6 .6</td><td>.8 .8</td></tr><tr><td>MISTRAL [26]</td><td>7B</td><td>base +extra</td><td>28.7 23.8</td><td>28.1</td><td>55.2</td><td>76.4 83.8</td><td>2</td><td></td><td>.8 .8</td></tr><tr><td rowspan="4">CodeGen2 [45]</td><td rowspan="2">16B4</td><td>base</td><td>19.5</td><td>23.7</td><td>48.5</td><td>76.4</td><td></td><td></td><td></td></tr><tr><td> +extra</td><td>16.5</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>7B</td><td>base +extra</td><td>18.3</td><td>17.9 30.9</td><td></td><td>50.9</td><td>2.2.2.2.</td><td>.6 .6</td><td>.8 .8</td></tr><tr><td>3B</td><td>base</td><td>16.5 15.9</td><td>15.9 15.2</td><td>27.1 23.9</td><td>45.4 38.6</td><td></td><td>.4</td><td>.8</td></tr><tr><td rowspan="3"></td><td rowspan="2">1B</td><td> +extra</td><td>12.8</td><td>12.9 21.2</td><td>34.3</td><td></td><td>.2</td><td>.4 .6</td><td>.8 .6</td></tr><tr><td>base</td><td>11.0</td><td>10.2 15.1</td><td></td><td>24.7</td><td>.2</td><td>.6</td><td>.6</td></tr><tr><td>+extra</td><td></td><td>9.1 8.7</td><td>13.7</td><td>21.2</td><td></td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td rowspan="2">VICUNA [12]</td><td rowspan="2">13B</td><td>base +extra</td><td>16.5 15.2</td><td>15.3 13.9</td><td>30.1 25.8</td><td>54.8</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>base</td><td>11.6</td><td>10.9</td><td>23.8</td><td>46.7 42.3</td><td>.2 .2</td><td>.6</td><td>.6</td></tr><tr><td>SantaCoder [2]</td><td>7B</td><td>+extra</td><td>11.0</td><td>10.3</td><td>20.3</td><td>35.0</td><td>.4</td><td>.6 .6</td><td>.6 .8</td></tr><tr><td rowspan="2"></td><td rowspan="2">1.1B</td><td>base +extra</td><td>14.6 12.8</td><td>16.6 14.2</td><td>29.2</td><td>45.4 40.6</td><td>.4</td><td>.6</td><td>.8</td></tr><tr><td></td><td>15.9</td><td>26.2 27.7</td><td></td><td>45.0</td><td>.2</td><td>.4</td><td>.6</td></tr><tr><td rowspan="3">INCODER [18]</td><td rowspan="2">6.7B</td><td>base</td><td>12.2</td><td>15.6</td><td></td><td></td><td>.2</td><td>.6</td><td>.6</td></tr><tr><td>+extra base</td><td>12.2</td><td>12.4 10.0</td><td>22.2 15.9</td><td>38.9 25.2</td><td>.2 .2</td><td>.6</td><td>.6</td></tr><tr><td>1.3B</td><td>+extra</td><td>10.4 7.9</td><td>13.5</td><td>20.7</td><td></td><td></td><td>.6</td><td>.4</td></tr><tr><td rowspan="2">GPT-J[63]</td><td rowspan="2">6B</td><td>base</td><td>12.2</td><td>11.3</td><td>17.7</td><td>31.8</td><td>.2 .2</td><td>.6</td><td>.6</td></tr><tr><td>+extra</td><td>10.4</td><td>9.5 15.2</td><td></td><td>25.9</td><td></td><td>.6</td><td>.6</td></tr><tr><td>GPT-NE0 [5]</td><td>2.7B</td><td>base</td><td>7.9</td><td>6.5</td><td>11.8</td><td>20.7</td><td>.2 .2</td><td>.6 .6</td><td>.6 .6</td></tr><tr><td rowspan="2"></td><td rowspan="2"></td><td>+extra</td><td>6.7</td><td>6.0</td><td>9.0</td><td>16.8 17.1</td><td></td><td></td><td>.6</td></tr><tr><td>base</td><td>6.1</td><td>5.9 10.2</td><td></td><td></td><td>2</td><td>.4</td><td>.6 .6</td></tr><tr><td rowspan="2">PolyCoder [70] StableLM[60]</td><td rowspan="2">2.7B 7B</td><td>+extra base</td><td>5.5 2.4</td><td>5.3 2.7</td><td>7.9 7.5</td><td>13.6 15.8</td><td>.2 .2</td><td>.6 .6</td></table>
+Table 4: Reduced test-suite for HUMANEVAL+. We first show the pass $@ 1 ^ { \star }$ and average #tests (including base HUMANEVAL tests) by only doing set covering over each considered metric separately (§2.2). The Full column then shows the final reduction result by combining all of the three. For reference, the average #tests of original HUMANEVAL and HUMANEVAL+ are 9.6 and 774.8 respectively (Table 2).
+<table><tr><td rowspan="2"></td><td rowspan="2">Size</td><td colspan="2">Coverage</td><td colspan="2">Killed mutants</td><td colspan="2">Killed samples</td><td colspan="2">Full</td><td colspan="2">Ref. pass@1*</td></tr><tr><td>pass@1*</td><td>#tests</td><td>pass@1*</td><td>#tests</td><td>pass@1*</td><td>#tests</td><td>pass@1*</td><td>#tests</td><td>base</td><td>+extra</td></tr><tr><td>GPT-4</td><td>N/A</td><td>86.0</td><td>11.3</td><td>82.9</td><td>11.4</td><td>78.7</td><td>13.8</td><td>78.0</td><td>16.1</td><td>88.4</td><td>76.2</td></tr><tr><td>ChatGPT</td><td>N/A</td><td>71.3</td><td>11.3</td><td>69.5</td><td>11.4</td><td>65.2</td><td>13.7</td><td>65.2</td><td>16.0</td><td>73.2</td><td>63.4</td></tr><tr><td>StarCoder</td><td>15B</td><td>32.9</td><td>11.3</td><td>32.9</td><td>11.4</td><td>29.3</td><td>13.6</td><td>29.3</td><td>15.9</td><td>34.1</td><td>29.3</td></tr><tr><td rowspan="3">CodeGen</td><td>2B</td><td>23.2</td><td>11.3</td><td>23.8</td><td>11.4</td><td>21.3</td><td>13.2</td><td>21.3</td><td>15.4</td><td>24.4</td><td>20.7</td></tr><tr><td>6B</td><td>28.7</td><td>11.3</td><td>29.3</td><td>11.4</td><td>25.6</td><td>13.2</td><td>25.6</td><td>15.4</td><td>29.3</td><td>25.6</td></tr><tr><td>16B</td><td>31.7</td><td>11.3</td><td>31.1</td><td>11.4</td><td>27.4</td><td>13.2</td><td>27.4</td><td>15.4</td><td>32.9</td><td>26.8</td></tr><tr><td rowspan="4">CodeGen2</td><td>1B</td><td>10.4</td><td>11.3</td><td>11.0</td><td>11.4</td><td>9.1</td><td>13.8</td><td>9.1</td><td>16.0</td><td>11.0</td><td>9.1</td></tr><tr><td>3B</td><td>15.9</td><td>11.3</td><td>15.9</td><td>11.4</td><td>12.8</td><td>13.8</td><td>12.8</td><td>16.0</td><td>15.9</td><td>12.8</td></tr><tr><td>7B</td><td>18.3</td><td>11.3</td><td>18.3</td><td>11.4</td><td>16.5</td><td>13.8</td><td>16.5</td><td>16.0</td><td>18.3</td><td>16.5</td></tr><tr><td>16B</td><td>19.5</td><td>11.3</td><td>18.9</td><td>11.4</td><td>16.5</td><td>13.8</td><td>16.5</td><td>16.0</td><td>19.5</td><td>16.5</td></tr><tr><td rowspan="2">VICUNA</td><td>7B</td><td>11.6</td><td>11.3</td><td>11.6</td><td>11.4</td><td>11.0</td><td>13.8</td><td>11.0</td><td>16.1</td><td>11.6</td><td>10.4</td></tr><tr><td>13B</td><td>16.5</td><td>11.3</td><td>16.5</td><td>11.4</td><td>15.2</td><td>13.8</td><td>15.2</td><td>16.1</td><td>17.1</td><td>15.2</td></tr><tr><td rowspan="2">SantaCoder</td><td>1.1B</td><td>14.6</td><td>11.3</td><td>14.6</td><td>11.4</td><td>12.8</td><td>13.8</td><td>12.8</td><td>16.1</td><td>14.6</td><td>12.8</td></tr><tr><td>1.3B</td><td>12.2</td><td>11.3</td><td>12.2</td><td>11.4</td><td>10.4</td><td>13.6</td><td>10.4</td><td>16.0</td><td>12.2</td><td>10.4</td></tr><tr><td rowspan="2">INCODER GPT-J</td><td>6.7B</td><td>14.6</td><td>11.3</td><td>14.6</td><td>11.4</td><td>12.2</td><td>13.6</td><td>12.2</td><td>16.0</td><td>15.9</td><td>12.2</td></tr><tr><td>6B</td><td>12.2</td><td>11.3</td><td>12.2</td><td>11.4</td><td>10.4</td><td>13.8</td><td>10.4</td><td>16.0</td><td>12.2</td><td>10.4</td></tr><tr><td>GPT-NEO</td><td>2.7B</td><td>7.3</td><td>11.3</td><td>7.3</td><td>11.4</td><td>6.7</td><td>13.8</td><td>6.7</td><td>16.1</td><td>7.9</td><td>6.7</td></tr><tr><td>PolyCoder</td><td>2.7B</td><td>6.1</td><td>11.3</td><td>6.1</td><td>11.4</td><td>5.5</td><td>13.8</td><td>5.5</td><td>16.1</td><td>6.1</td><td>5.5</td></tr><tr><td>StableLM</td><td>7B</td><td>2.4</td><td>11.3</td><td>2.4</td><td>11.4</td><td>2.4</td><td>13.8</td><td>2.4</td><td>16.1</td><td>2.4</td><td>2.4</td></tr></table>
+We also show that a more rigorous evaluation could yield different or totally contradictory relative results. For example, WizardCoder-CodeLlama and Phind-CodeLlama on the original HUMANEVAL are evaluated to be no better than ChatGPT in terms of pass $@ 1 ^ { \star }$ . However, HUMANEVAL+ demonstrates that the two open-source models can actually outperform the proprietary ChatGPT. Other contrary examples reflected by HUMANEVAL+ include that SantaCoder-1B surpasses INCODER-6.7B and VICUNA-7B outperforms INCODER-1.3B. Table 3 further illustrates the distribution of best-performing temperatures over different $k$ values. Our results conforms with prior findings [11] that a lower temperature tends to perform better for smaller $k$ , while a higher temperature works better for larger $k$ . We also observe that the optimal temperatures seem to stay fairly consistent before and after using HUMANEVAL+; however, slight differences still exist, e.g., best temperature for CodeGen-2B on pass $@ 1 0$ becomes 0.2 from 0.8 after using HUMANEVAL+. Nonetheless, this motivates future research to look more closely on the effect of temperature with respect to the robustness of the evaluation tests, esp. those edge-cases.
+Effectiveness of test-suite reduction. Based on HUMANEVAL+ which on average obtains 764.1 tests for each programming task (Table 2), our test-suite reducer $( \ S 2 . 2 )$ minimizes it to HUMANEVAL+- MINI which only has 16.1 tests for each task (smaller by $4 7 \times$ ). Table 4 performs leave-one-out cross validation to show the pass $@ 1 ^ { \star }$ differences over a subset of representative models studied in Table 3 (due to time/space constraints). That is, for each evaluated LLM we construct the reduced test-suite without considering its own sample kills. The Full column shows that the reduced test-suite can achieve almost the same pass $@ 1 ^ { \star }$ drop as HUMANEVAL+ by only using $4 7 \times$ fewer test-cases. Taking a closer look, separately performing set covering over each metric can harness the pass $@ 1 ^ { \star }$ of the base HUMANEVAL to certain degree. Specifically, the use of empirical LLM sample killings is the most effective, leading to the same effectiveness as the full approach, but also consumes more tests than other theoretical metrics. While using coverage and mutation analysis seems to be unnecessary in addition to using sample killings, they still serve as the base guarantees for the theoretical test adequacy.
+Pass rate distribution. Figure 3 shows for each programming task the overall pass rates on HUMANEVAL and HUMANEVAL+ tests. The pass rate gap between HUMANEVAL and HUMANEVAL+ shows overall HUMANEVAL+ can detect solutions that are misidentified by HUMANEVAL for problems of all levels of difficulties. We also observe that problems in HUMANEVAL are not equal, not only in terms of problem difficulty but also the difficulty of generating counter-examples and edge-cases to deeply exercise LLM-generated code. For simple problems such as “adding two numbers” and “length of a string” (i.e., problems with top-2 pass rates), it is easy to solve for LLMs and to test manually. While problems dealing with multiple conditions (e.g., “word splitting”), completeness (e.g., handling negative numbers for “is-prime”) , reasoning ability (e.g., “Tribonacci sequence”) and efficiency requirements (e.g., “n-th prime Fibonacci number”) are the hardest tasks to the evaluated LLMs, positioning future research to improve LLMs for conquering such coding skills.
+![](images/8957033a3d75d416829c6f5be232a3f78cb93a579c8114a591c0782819eac96d.jpg)
+Figure 3: Pass rate distribution. X-axis spans bars for all 164 problems, sorted by the HUMANEVAL pass rate. Y-axis shows the log-scale pass rates averaged by all LLM-generated samples.
+Incorrect “ground-truth” in HUMANEVAL. In addition to detecting wrong code from LLMs using EvalPlus, we also found 18 defects ( $1 1 \%$ of problems) even in the original ground-truth in HUMANEVAL, including (i) Unhandled edge-case: five prior ground-truths fail to handle corner-case inputs (e.g., empty list or string); (ii) Bad logic: 10 prior ground-truths incorrectly implement the desired functionality; and (iii) Performance issue: three inefficient implementations lead to slow performance on reasonably-sized inputs. Among those, bad logic (10) is the most serious as the original “groundtruth” does not accurately reflect the user intent. Such defects are detected also through differential testing but between our own re-implemented ground-truth and the original ground-truth in HUMANEVAL.
+![](images/343bed10bdc118b6c4dec60fa0c9e6e3926d4db9f0838f1b97fa215f9f8ee865.jpg)
+Figure 4: Exemplary incorrect-logic ground-truth solution in HUMANEVAL (#124)
+Figure 4 shows an incorrect ground-truth implementation (validate_date) from HUMANEVAL classified as having bad logic. The desired task is to check if the input date format is correct. We see that in the core logic, the conditions attempt to first check the month condition and then handle the corresponding day conditions. However, this is implemented incorrectly as “and” in Python5 has higher precedence than “or”, leading to the ground-truth function to check if either conditions satisfies instead of the desired both conditions must satisfy. This is exposed via our automatically generated test input of 12-31-1999 where the ground-truth implementation incorrectly labels this as not a valid date. Surprisingly this egregious error is not exposed by any of the base test inputs in HUMANEVAL, further demonstrating the weakness and limited evaluation power of the original test inputs.
+# 4 Related Work
+LLMs for code. The use of LLMs for code has gained traction in recent years, owing to the abundance of open codebase and the need for improving developer efficiency. LLMs have demonstrated state-of-the-art performance on various code-related tasks, including code generation [11, 33, 25], program repair [69, 27, 68, 65], automated testing [15, 14, 67, 35, 71], code translation [31, 55] and code summarization [1, 37]. In particular, prominent LLMs including CODEX [11], CodeGen [46], INCODER [18] and PolyCoder [70], have been developed and extensively evaluated for code generation (widely recognized as the holy grail for computer science research since the inception of AI in the 1950s [21]), where the model generates code snippets based on natural language descriptions (e.g., docstring) of the desired functionality.
+Coding benchmark for LLMs. LLM-based code synthesis is largely evaluated based on functional correctness, which is typically assessed by running test-cases to check the desired outputs. HUMANEVAL [11] is one of the pioneering and most widely studied human-written benchmarks for LLM-based code synthesis, consisting of 164 pairs of Python function signature with docstring and the associated test-cases for correctness checking. Additionally, each HUMANEVAL problem is also equipped with a reference solution. Another Python-focused dataset, MBPP [3], is created by crowd-sourcing participants to write in summation 974 programming problems, each of which is comprised of the problem statement (i.e., docstring), the function signature, as well as three test-cases. Beyond Python, there are other benchmarks targeting additional languages such as Spider [73] (SQL), HUMANEVAL-X [76] $^ { ( \mathrm { C + + } }$ , Javascript and Go), CodeContests [33] ( $\scriptstyle ( + +$ and Java) and MultiPL-E [9] (extending HUMANEVAL and MBPP to 18 programming languages). More recently, researchers have created a more realistic code synthesis benchmark by collecting GitHub issues along with the corresponding code base together with tests to measure the ability of LLMs to perform real-world software engineering tasks [28]. Our work shows for the first time the test inadequacy problem of widely studied benchmarks and addresses the issue via automatic test generation.
+Automated test generation. Automated test generation is a widely used for finding software bugs with automatically generated tests. Black-box test generation such as fuzz testing [43] feeds random inputs (e.g., random bytes) to the system under test (SUT), without knowing its source code. Traditional black-box techniques can mainly be categorized into generation-based [72, 23, 56] and mutationbased [66, 10, 47] ones. White-box approaches provide better-quality test-cases by analyzing the source code of SUT. For instance, symbolic execution [30, 8] breaks the coverage plateaus by solving symbolic path constraints to generate tests targeting deep paths. As a mid-point, coverage-guided fuzzing [74, 57] (i.e., grey-box) uses the coverage information of SUT as feedback to adjust the input generation and mutation. The discussed traditional methods are inapplicable to generating semantically meaningful inputs for arbitrary problems programmed in a dynamically-typed language. We address this by using ChatGPT to inspect the ground-truth (i.e., white-box) for initializing interesting seeds, based on which type-aware mutation (i.e., black-box) scales the test inputs to a large amount.
+# 5 Conclusion & Future Work
+We present EvalPlus – a rigorous evaluation framework for program synthesis, driven by automated test generation. EvalPlus combines both LLM- and mutation-based input generation to obtain a diverse set of test inputs for accurately evaluating the correctness of LLM-generated code. EvalPlus creates HUMANEVAL+, built on top of the popular HUMANEVAL with additional high-quality and automatically generated test inputs. With test-suite reduction, EvalPlus also produces HUMANEVAL+-MINI which is smaller than HUMANEVAL+ by $4 7 \times$ while preserving similar test effectiveness. We extensively evaluate a diverse set of LLMs and show that HUMANEVAL+ can identify a significant amount of previously undetected wrong code generated by LLMs, demonstrating its effectiveness to augment programming benchmarks for more accurate evaluation.
+Since launched, the EvalPlus PyPI package has been installed by over 6k times in 5 months. We also keep evaluating new models for code and maintain a leaderboard at https://evalplus.github. io/leaderboard.html. In the future, we plan to apply EvalPlus to bring better-quality testing for more code benchmarks such as MBPP. Meanwhile. future work can look into how to integrate EvalPlus with more formal verification (e.g., Dafny [32]) or validation techniques (e.g., translation validation [36]) to provide stronger guarantees of the evaluation results when applicable. Additionally, the core test generation technique behind can be even used to remind developers of potential flaws of the accepted LLM-generated code snippets when doing AI pair-programming (e.g., Copilot [42]).
+# 6 Acknowledgements
+This work was partially supported by NSF grants CCF-2131943 and CCF-2141474, as well as Kwai Inc. We thank the reviewers for their invaluable feedback. We further thank Yinlin Deng for providing helpful discussions, as well as Junhao Wang and Songrun Xie for their open-source contributions.
+References
+[1] T. Ahmed and P. Devanbu. Few-shot training llms for project-specific code-summarization. In 37th IEEE/ACM International Conference on Automated Software Engineering, pages 1–5, 2022.
+[2] L. B. Allal, R. Li, D. Kocetkov, C. Mou, C. Akiki, C. M. Ferrandis, N. Muennighoff, M. Mishra, A. Gu, M. Dey, et al. Santacoder: don’t reach for the stars! arXiv preprint arXiv:2301.03988, 2023.
+[3] J. Austin, A. Odena, M. Nye, M. Bosma, H. Michalewski, D. Dohan, E. Jiang, C. Cai, M. Terry, Q. Le, and C. Sutton. Program synthesis with large language models, 2021.
+[4] S. Bang, S. Nam, I. Chun, H. Y. Jhoo, and J. Lee. Smt-based translation validation for machine learning compiler. In Computer Aided Verification: 34th International Conference, CAV 2022, Haifa, Israel, August 7–10, 2022, Proceedings, Part II, pages 386–407. Springer, 2022.
+[5] S. Black, L. Gao, P. Wang, C. Leahy, and S. Biderman. GPT-Neo: Large Scale Autoregressive Language Modeling with Mesh-Tensorflow, Mar. 2021. If you use this software, please cite it using these metadata.
+[6] T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020.
+[7] T. A. Budd. Mutation analysis of program test data. Yale University, 1980.
+[8] C. Cadar, D. Dunbar, D. R. Engler, et al. Klee: unassisted and automatic generation of high-coverage tests for complex systems programs. In OSDI, volume 8, pages 209–224, 2008.
+[9] F. Cassano, J. Gouwar, D. Nguyen, S. Nguyen, L. Phipps-Costin, D. Pinckney, M.-H. Yee, Y. Zi, C. J. Anderson, M. Q. Feldman, et al. Multipl-e: A scalable and polyglot approach to benchmarking neural code generation. IEEE Transactions on Software Engineering, 2023.
+[10] S. K. Cha, M. Woo, and D. Brumley. Program-adaptive mutational fuzzing. In 2015 IEEE Symposium on Security and Privacy, pages 725–741. IEEE, 2015.
+[11] M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P. d. O. Pinto, J. Kaplan, H. Edwards, Y. Burda, N. Joseph, G. Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021.
+[12] W.-L. Chiang, Z. Li, Z. Lin, Y. Sheng, Z. Wu, H. Zhang, L. Zheng, S. Zhuang, Y. Zhuang, J. E. Gonzalez, I. Stoica, and E. P. Xing. Vicuna: An open-source chatbot impressing gpt-4 with $9 0 \% *$ chatgpt quality, March 2023.
+[13] B. Code. Starcoder. https://github.com/bigcode-project/starcoder, 2023.
+[14] Y. Deng, C. S. Xia, H. Peng, C. Yang, and L. Zhang. Large language models are zero-shot fuzzers: Fuzzing deep-learning libraries via large language models. In 32nd International Symposium on Software Testing and Analysis (ISSTA), 2023.
+[15] Y. Deng, C. S. Xia, C. Yang, S. D. Zhang, S. Yang, and L. Zhang. Large language models are edge-case fuzzers: Testing deep learning libraries via fuzzgpt. In 46th International Conference on Software Engineering (ICSE), 2024.
+[16] fauxpilot. Fauxpilot: an open-source alternative to github copilot server. https: //github.com/fauxpilot/fauxpilot, 2022.
+[17] U. Feige. A threshold of ln n for approximating set cover. Journal of the ACM (JACM), 45(4):634–652, 1998.
+[18] D. Fried, A. Aghajanyan, J. Lin, S. Wang, E. Wallace, F. Shi, R. Zhong, S. Yih, L. Zettlemoyer, and M. Lewis. Incoder: A generative model for code infilling and synthesis. In The Eleventh International Conference on Learning Representations, 2023.
+[19] C. Green. Application of theorem proving to problem solving. In Readings in Artificial Intelligence, pages 202–222. Elsevier, 1981.
+[20] S. Gulwani. Automating string processing in spreadsheets using input-output examples. SIGPLAN Not., 46(1):317–330, jan 2011.
+[21] S. Gulwani, O. Polozov, and R. Singh. Program synthesis. Foundations and Trends® in Programming Languages, 4(1-2):1–119, 2017.
+[22] T. Hastie, R. Tibshirani, J. H. Friedman, and J. H. Friedman. The elements of statistical learning: data mining, inference, and prediction, volume 2. Springer, 2009.
+[23] C. Holler, K. Herzig, and A. Zeller. Fuzzing with code fragments. In 21st USENIX Security Symposium (USENIX Security 12), pages 445–458, Bellevue, WA, Aug. 2012. USENIX Association.
+[24] M. Ivankovic, G. Petrovi ´ c, R. Just, and G. Fraser. Code coverage at google. In ´ Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 955–963, 2019.
+[25] S. Iyer, I. Konstas, A. Cheung, and L. Zettlemoyer. Mapping language to code in programmatic context. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 1643–1652, 2018.
+[26] A. Q. Jiang, A. Sablayrolles, A. Mensch, C. Bamford, D. S. Chaplot, D. d. l. Casas, F. Bressand, G. Lengyel, G. Lample, L. Saulnier, et al. Mistral 7b. arXiv preprint arXiv:2310.06825, 2023.
+[27] N. Jiang, K. Liu, T. Lutellier, and L. Tan. Impact of code language models on automated program repair. arXiv preprint arXiv:2302.05020, 2023.
+[28] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan. Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770, 2023.
+[29] A. Kalyan, A. Mohta, O. Polozov, D. Batra, P. Jain, and S. Gulwani. Neural-guided deductive search for real-time program synthesis from examples. In International Conference on Learning Representations, 2018.
+[30] J. C. King. Symbolic execution and program testing. Communications of the ACM, 19(7):385–394, 1976.
+[31] M.-A. Lachaux, B. Roziere, L. Chanussot, and G. Lample. Unsupervised translation of programming languages. arXiv preprint arXiv:2006.03511, 2020.
+[32] K. R. M. Leino. Dafny: An automatic program verifier for functional correctness. In International conference on logic for programming artificial intelligence and reasoning, pages 348–370. Springer, 2010.
+[33] Y. Li, D. Choi, J. Chung, N. Kushman, J. Schrittwieser, R. Leblond, T. Eccles, J. Keeling, F. Gimeno, A. Dal Lago, et al. Competition-level code generation with alphacode. Science, 378(6624):1092–1097, 2022.
+[34] J. Liu, Y. Wei, S. Yang, Y. Deng, and L. Zhang. Coverage-guided tensor compiler fuzzing with joint ir-pass mutation. Proceedings of the ACM on Programming Languages, 6(OOPSLA1):1–26, Apr. 2022.
+[35] Z. Liu, C. Chen, J. Wang, X. Che, Y. Huang, J. Hu, and Q. Wang. Fill in the blank: Context-aware automated text input generation for mobile gui testing. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pages 1355–1367. IEEE, 2023.
+[36] N. P. Lopes, J. Lee, C.-K. Hur, Z. Liu, and J. Regehr. Alive2: bounded translation validation for llvm. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation, pages 65–79, 2021.
+[37] S. Lu, D. Guo, S. Ren, J. Huang, A. Svyatkovskiy, A. Blanco, C. Clement, D. Drain, D. Jiang, D. Tang, et al. Codexglue: A machine learning benchmark dataset for code understanding and generation. arXiv preprint arXiv:2102.04664, 2021.
+[38] Z. Luo, C. Xu, P. Zhao, Q. Sun, X. Geng, W. Hu, C. Tao, J. Ma, Q. Lin, and D. Jiang. Wizardcoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568, 2023.
+[39] Z. Manna and R. J. Waldinger. Toward automatic program synthesis. Communications of the ACM, 14(3):151–165, 1971.
+[40] W. M. McKeeman. Differential testing for software. Digital Technical Journal, 10(1):100–107, 1998.
+[41] B. Meyer. Applying’design by contract’. Computer, 25(10):40–51, 1992.
+[42] Microsoft. GitHub Copilot – Your AI pair programmer. https://github.com/features/ copilot, 2023.
+[43] B. P. Miller, L. Fredriksen, and B. So. An empirical study of the reliability of unix utilities. Communications of the ACM, 33(12):32–44, 1990.
+[44] G. C. Necula. Translation validation for an optimizing compiler. In Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation, pages 83–94, 2000.
+[45] E. Nijkamp, H. Hayashi, C. Xiong, S. Savarese, and Y. Zhou. Codegen2: Lessons for training llms on programming and natural languages. arXiv preprint, 2023.
+[46] E. Nijkamp, B. Pang, H. Hayashi, L. Tu, H. Wang, Y. Zhou, S. Savarese, and C. Xiong. Codegen: An open large language model for code with multi-turn program synthesis. In The Eleventh International Conference on Learning Representations, 2023.
+[47] P. Oehlert. Violating assumptions with fuzzing. IEEE Security & Privacy, 3(2):58–62, 2005.
+[48] OpenAI. Chatgpt: Optimizing language models for dialogue. https://openai.com/blog/ chatgpt/, 2022.
+[49] OpenAI. Gpt-4 technical report. ArXiv, abs/2303.08774, 2023.
+[50] K. Papineni, S. Roukos, T. Ward, and W.-J. Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, pages 311–318, 2002.
+[51] G. Petrovic and M. Ivankovi ´ c. State of mutation testing at google. In ´ Proceedings of the 40th international conference on software engineering: Software engineering in practice, pages 163–171, 2018.
+[52] Phind. Phind/phind-codellama-34b-v2 $\cdot$ hugging face. https://huggingface.co/Phind/ Phind-CodeLlama-34B-v2, 2023.
+[53] G. Rothermel, M. J. Harrold, J. Von Ronne, and C. Hong. Empirical studies of test-suite reduction. Software Testing, Verification and Reliability, 12(4):219–249, 2002.
+[54] B. Rozière, J. Gehring, F. Gloeckle, S. Sootla, I. Gat, X. E. Tan, Y. Adi, J. Liu, T. Remez, J. Rapin, et al. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950, 2023.
+[55] B. Roziere, J. M. Zhang, F. Charton, M. Harman, G. Synnaeve, and G. Lample. Leveraging automated unit tests for unsupervised code translation. arXiv preprint arXiv:2110.06773, 2021.
+[56] M. Security. jsfunfuzz. https://github.com/MozillaSecurity/funfuzz, 2007.
+[57] K. Serebryany. Continuous fuzzing with libfuzzer and addresssanitizer. In 2016 IEEE Cybersecurity Development (SecDev), pages 157–157. IEEE, 2016.
+[58] D. E. Shaw, W. R. Swartout, and C. C. Green. Inferring lisp programs from examples. In IJCAI, volume 75, pages 260–267, 1975.
+[59] A. Shi, A. Gyori, M. Gligoric, A. Zaytsev, and D. Marinov. Balancing trade-offs in test-suite reduction. In Proceedings of the 22nd ACM SIGSOFT international symposium on foundations of software engineering, pages 246–256, 2014.
+[60] Stability-AI. Stablelm: Stability ai language models. https://github.com/Stability-AI/ StableLM, 2023.
+[61] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.
+[62] R. J. Waldinger and R. C. Lee. Prow: A step toward automatic program writing. In Proceedings of the 1st international joint conference on Artificial intelligence, pages 241–252, 1969.
+[63] B. Wang and A. Komatsuzaki. GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model. https://github.com/kingoflolz/mesh-transformer-jax, May 2021.
+[64] Y. Wang, H. Le, A. D. Gotmare, N. D. Bui, J. Li, and S. C. Hoi. Codet5 $^ +$ : Open code large language models for code understanding and generation. arXiv preprint arXiv:2305.07922, 2023.
+[65] Y. Wei, C. S. Xia, and L. Zhang. Copiloting the copilots: Fusing large language models with completion engines for automated program repair. arXiv preprint arXiv:2309.00608, 2023.
+[66] D. Winterer, C. Zhang, and Z. Su. On the unusual effectiveness of type-aware operator mutations for testing smt solvers. Proceedings of the ACM on Programming Languages, 4(OOPSLA):1–25, 2020.
+[67] C. S. Xia, M. Paltenghi, J. L. Tian, M. Pradel, and L. Zhang. Universal fuzzing via large language models. In 46th International Conference on Software Engineering (ICSE), 2024.
+[68] C. S. Xia, Y. Wei, and L. Zhang. Automated program repair in the era of large pre-trained language models. In Proceedings of the 45th International Conference on Software Engineering (ICSE 2023). Association for Computing Machinery, 2023.
+[69] C. S. Xia and L. Zhang. Less training, more repairing please: revisiting automated program repair via zero-shot learning. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 959–971, 2022.
+[70] F. F. Xu, U. Alon, G. Neubig, and V. J. Hellendoorn. A systematic evaluation of large language models of code. In Proceedings of the 6th ACM SIGPLAN International Symposium on Machine Programming, pages 1–10, 2022.
+[71] C. Yang, Y. Deng, R. Lu, J. Yao, J. Liu, R. Jabbarvand, and L. Zhang. White-box compiler fuzzing empowered by large language models, 2023.
+[72] X. Yang, Y. Chen, E. Eide, and J. Regehr. Finding and understanding bugs in c compilers. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’11, page 283–294, New York, NY, USA, 2011. Association for Computing Machinery.
+[73] T. Yu, R. Zhang, K. Yang, M. Yasunaga, D. Wang, Z. Li, J. Ma, I. Li, Q. Yao, S. Roman, et al. Spider: A large-scale human-labeled dataset for complex and cross-domain semantic parsing and text-to-sql task. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 2018.
+[74] M. Zalewski. American fuzzing lop (afl). https://lcamtuf.coredump.cx/afl/, 2018.
+[75] L. Zhang, D. Marinov, L. Zhang, and S. Khurshid. An empirical study of junit test-suite reduction. In 2011 IEEE 22nd International Symposium on Software Reliability Engineering, pages 170–179. IEEE, 2011.
+[76] Q. Zheng, X. Xia, X. Zou, Y. Dong, S. Wang, Y. Xue, Z. Wang, L. Shen, A. Wang, Y. Li, et al. Codegeex: A pre-trained model for code generation with multilingual evaluations on humaneval-x. arXiv preprint arXiv:2303.17568, 2023.
+Table 5: Overview of evaluated models.
+<table><tr><td>Model Name</td><td>Sizes</td><td>Release Year</td><td>Open-Source</td></tr><tr><td rowspan="10">Cuipoo</td><td>2B,6B,16B</td><td>2022 2022</td><td>&lt;</td></tr><tr><td>CodeGen [46] INCODER [18]</td><td>1.3B, 6.7B</td><td>√</td></tr><tr><td>PolyCoder [70]</td><td>2.7B</td><td>2022</td></tr><tr><td>SantaCoder [2]</td><td>1.1B 2023</td><td></td></tr><tr><td>CodeGen2 [45]</td><td>1B,3B,7B,16B</td><td>2023</td></tr><tr><td>StarCoder[13]</td><td>15B 2023</td><td></td></tr><tr><td>CODET5+ [64]</td><td>16B 2023</td><td></td></tr><tr><td>CODELLAMA [54]</td><td>7B,13B,34B 2023</td><td></td></tr><tr><td>WizardCoder-CodeLlama [38]</td><td>2023</td><td></td></tr><tr><td>34B Phind-CodeLlama [52] 34B</td><td>2023</td><td></td></tr><tr><td rowspan="7">GPT-J [63] Geeeeer StableLM [60]</td><td>6B</td><td>2021</td><td>√</td></tr><tr><td>GPT-NEO [5]</td><td>2.7B 2021</td><td>【</td></tr><tr><td>ChatGPT[48]</td><td>2022</td><td></td></tr><tr><td>GPT-4 [49]</td><td>N/A N/A</td><td></td></tr><tr><td>VICUNA [12]</td><td>2023 2023</td><td></td></tr><tr><td>7B,13B 7B</td><td>2023</td><td></td></tr><tr><td>MISTRAL [26]</td><td>2023</td><td></td></tr></table>
+# A Detailed Experimental Setup
+Evaluation of LLMs. Our goal is to comprehensively evaluate recent and widely used LLMs, both specialized for code generation [46, 70, 18, 2, 52, 38, 64] and general-purpose tasks [49, 48, 12, 60, 63, 5, 26]. Table 5 presents an overview of the studied models, with column Sizes reflecting the model sizes in billions of parameters, Release Year showing when the LLM is released, and Open-Source marking the models whose weights are publicly available. In total, we evaluate 26 of the most representative and popular LLMs with a broad range of configurations to fully demonstrate the generalizability of our results.
+Our hyper-parameter configurations follow prior work [11, 46]. For each model we randomly sample 200 programs and repeat the experiments over temperature $( \{ 0 . 2 , 0 . 4 , 0 . 6 , 0 . 8 \} )$ and greedy decoding with zero temperature. By default, we let each model generate at most 512 new tokens and truncate the produced code with end-of-string (EOS) identifiers suggested in HUMANEVAL [11], as well as those favoured by certain models (e.g., “<|endoftext $| > ^ { \dag }$ and $\cdots ( n ^ { - , - , 3 } )$ . For conversational models (i.e., ChatGPT and GPT-4), we obtain the code fragments by parsing the code blocks (i.e., within “\`\`\`”) in the output. We found ChatGPT tends to repeat problem description with detailed explanation, which can consume more than 512 new tokens to complete a solution for around $11 \%$ of problems. To align ChatGPT with other models, for tasks with very long problem descriptions, we extend the token limit from 512 to 1024. For model implementation, we run ChatGPT and GPT-4 via OpenAI APIs, and accelerate CodeGen-6B and -16B with NVIDIA FasterTransformer via FauxPilot [16]. All other LLMs are based on the HuggingFace transformers library. By default, we follow the official examples of each LLM (e.g., on HuggingFace model card) to construct their corresponding prompts. Specifically, the prompts used for ChatGPT, GPT-4, and WizardCoder-CodeLlama is instruction-based, i.e., a simple instruction is used to wrap the function signature and docstring to explicitly encourage the LLM for code generation.
+Test oracles. An LLM-produced solution is regarded to be correct if for all test inputs it returns values that match the expected outputs within a reasonable run time. We perform exact matching by default. For floating-point comparisons, we tolerate absolute differences to the degrees annotated in HUMANEVAL or $1 \bar { 0 } ^ { - 6 }$ if not annotated. In original HUMANEVAL, the default timeout is set to three seconds to run the whole test-suite (i.e., all test-cases) for each programming problem. Such a setting is neither suitable when having more test-cases nor reasonable as each problem could have its own run time characteristics. Consequently, we let the timeout for each test-case to be $\mathrm { m a x } ( 2 0 0 \mathrm { m s } , 4 \times t _ { g t } )$ where $t _ { g t }$ refers to the execution time of the corresponding ground-truth solution. In other words, we expect the LLM-provided solution to be no slower than the ground-truth by four times or use a base 200-millisecond timeout when $4 \times t _ { g t } < 2 0 0 \mathrm { m s }$ to avoid variance caused by performance randomness.

parse/dev/1qvx610Cu7/1qvx610Cu7_content_list.json ADDED Viewed

	@@ -0,0 +1,847 @@

+[
+    {
+        "type": "text",
+        "text": "Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation ",
+        "text_level": 1,
+        "bbox": [
+            192,
+            122,
+            807,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jiawei Liu ∗ Chunqiu Steven Xia ∗ Yuyao Wang Lingming Zhang ",
+        "bbox": [
+            222,
+            242,
+            776,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "University of Illinois Urbana-Champaign Nanjing University ",
+        "bbox": [
+            261,
+            277,
+            725,
+            296
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{jiawei6, chunqiu2, lingming}@illinois.edu yuyao6@outlook.com ",
+        "bbox": [
+            232,
+            309,
+            766,
+            324
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            359,
+            535,
+            376
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Program synthesis has been long studied with recent approaches focused on directly using the power of Large Language Models (LLMs) to generate code. Programming benchmarks, with curated synthesis problems and test-cases, are used to measure the performance of various LLMs on code synthesis. However, these test-cases can be limited in both quantity and quality for fully assessing the functional correctness of the generated code. Such limitation in the existing benchmarks begs the following question: In the era of LLMs, is the code generated really correct? To answer this, we propose EvalPlus – a code synthesis evaluation framework to rigorously benchmark the functional correctness of LLM-synthesized code. EvalPlus augments a given evaluation dataset with large amounts of test-cases newly produced by an automatic test input generator, powered by both LLM- and mutation-based strategies. While EvalPlus is general, we extend the test-cases of the popular HUMANEVAL benchmark by $8 0 \\times$ to build HUMANEVAL+. Our extensive evaluation across 26 popular LLMs (e.g., GPT-4 and ChatGPT) demonstrates that HUMANEVAL+ is able to catch significant amounts of previously undetected wrong code synthesized by LLMs, reducing the pass $@ k$ by up-to $1 9 . 3 \\substack { - 2 8 . 9 \\% }$ . We also surprisingly found that test insufficiency can lead to mis-ranking. For example, both WizardCoder-CodeLlama and Phind-CodeLlama now outperform ChatGPT on HUMANEVAL+, while none of them could on HUMANEVAL. Our work not only indicates that prior popular code synthesis evaluation results do not accurately reflect the true performance of LLMs for code synthesis, but also opens up a new direction to improve such programming benchmarks through automated testing. We have open-sourced our tools, enhanced datasets as well as all LLM-generated code at https://github.com/evalplus/evalplus to facilitate and accelerate future LLM-for-code research. ",
+        "bbox": [
+            232,
+            392,
+            766,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            310,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Automatically generating programs that accurately correspond to user intents is a long-standing challenge in computer science known as program synthesis [21]. In the past few decades, classical program synthesis techniques have been developed, including deductive synthesis [19, 39, 62], inductive synthesis [20, 58] and neural-guided synthesis [29]. More recently, with the advent of Large Language Models [61, 6] (LLMs) and the abundance of open codebase, researchers have been focusing on applying LLMs for direct code generation. LLMs like CODEX [11] and CodeGen [46] perform code generation by autoregressively predicting the next token given previous context, in the form of function signature and docstring that denote the desired program functionality. The generated code snippet is then combined with the context to form a complete function that aligns with the user intent. Leveraging both natural language understanding and generative power, LLMs have demonstrated impressive performance in code synthesis [3, 11]. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3123815fc6ee764f610b9ae26921911c0080b9bf9a5fda7fb8f6bb0ec472825d.jpg",
+        "image_caption": [
+            "Figure 1: Exemplary wrong code synthesized by ChatGPT for HUMANEVAL #58. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            823,
+            162
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            215,
+            825,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The primary concern when it comes to LLM-generated code is correctness. Because two dramatically different code snippets can be semantically equivalent, classic NLP metrics like BLEU score [50] are no longer reliable in the context of program synthesis. Ideally, we would like to formally verify the correctness of LLM-provided solutions for any input, but verifying domain-specific problems through methods such as translation validation [36, 44, 4] is already challenging enough, let alone building a general verifier with absolute certainty to prove arbitrary problems, including those in code benchmarks. As such, existing code benchmarks (e.g., HUMANEVAL [11]) heavily rely on manually constructed test-cases to evaluate LLM solutions. However, these tests often fall short in capturing all possible scenarios, as crafting high-quality tests is laborious. Consequently, we argue that current programming benchmarks are inadequate for assessing the actual correctness of LLM-generated code, leading to false confidence in the results. Specifically, we have identified the following common limitations in existing LLM-for-code benchmarks: ",
+        "bbox": [
+            173,
+            291,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Insufficient testing. Current programming benchmarks often only include on average less than 10 tests for each coding problem. Furthermore, these tests are relatively too simple to fully explore the functionality of the code or corner cases. Figure 1 shows an incorrect code sample synthesized by ChatGPT [48] to return the sorted unique common elements from two lists. At first glance, the function looks correct and computes the desired output when using the base test inputs from HUMANEVAL. However, in the return statement, it incorrectly converts the intermediate list to a set which no longer preserves the order of the sorted list. This example shows that a logically flawed solution can still pass all simple tests and be misconsidered as correct due to testing inadequacy. Imprecise problem description. The input for code generation includes natural language descriptions in addition to the function signature. These task descriptions in existing benchmarks are oftentimes too vague to fully clarify the expected program behaviors. For example, the input docstring may not specify the expected input domain (e.g., only positive integers) or how the function should handle exceptions. As a result, such programming problems can be interpreted differently by LLMs against the actual tests, leading to capable LLMs misjudged as incapable. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "These limitations are common across many popular code generation benchmarks [11, 3, 33]. This not only questions the validity of the impressive performance claimed by prior work but also sets a challenge on how to properly evaluate the LLM coders. In this paper, we aim to address this fundamental evaluation challenge and ask the introspective question: Is the code generated by LLMs really correct? ",
+        "bbox": [
+            174,
+            667,
+            825,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our proposal. In this work, we set out to answer the important question and evaluate the evaluation dataset. Consequently, we build EvalPlus – an evaluation framework to improve existing code benchmarks in order to precisely evaluate the functional correctness of LLM-generated code. At the heart of EvalPlus is an automatic test input generation engine which augments existing code benchmarks by generating interesting test inputs to fully exercise the code solution and check its functional correctness by cross-checking the ground-truth implementation. Specifically, EvalPlus adopts both LLM- and mutation-based [57, 74, 47] methods to automatically generate and diversify additional test inputs. EvalPlus first uses ChatGPT [48] to generate a set of high-quality seed inputs that aim to test difficult corner cases and functionalities of the program within the valid input structure. Using these high-quality seed inputs, EvalPlus then performs type-aware mutation to efficiently generate a large number of additional test inputs. These newly generated test inputs are then used to evaluate the LLM-generated code through differential testing [40] against the ground-truth implementation. Furthermore, as an option to speed up evaluation, EvalPlus also builds minimal test-suites by only including the most valuable test-cases, which are selected by running a greedy set cover algorithm to preserve the same code coverage [24], mutation analysis [7] as well as empirical LLM sample killings. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/db8c3d3ffdb7024ce0d9bfd7ea7adb89d8b708b14a9e41e575743b2eb90d60f0.jpg",
+        "image_caption": [
+            "Figure 2: Overview of EvalPlus "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            88,
+            790,
+            337
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            387,
+            823,
+            415
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Contribution. Our work revisited and proposed to automatically improve code benchmarks for LLMs: ",
+        "bbox": [
+            174,
+            424,
+            821,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Study: We are the first to study the test inadequacy problem in current programming benchmarks which can lead to largely over-approximated functional correctness. Our study also opens up a new research direction for precisely and rigorously evaluating LLM-synthesized code. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Approach: We propose EvalPlus – an evaluation framework to reveal the real correctness of LLM-synthesized code. The test-case generation approach of EvalPlus combines the emerging LLM-based and traditional mutation-based test input generation. It first uses LLM-based strategy to bootstrap the test generator with high-quality seed inputs and then further extends large amounts of inputs via type-aware mutation. We then optionally “distill” the generated tests to a much smaller yet almost equivalently effective test-suite via greedy set covering. We also propose to annotate each programming tasks using program contracts to filter out invalid inputs. ",
+        "bbox": [
+            176,
+            488,
+            825,
+            584
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Results: EvalPlus extends the popular HUMANEVAL benchmark to create HUMANEVAL+, improving the test-case scale by $8 0 \\times$ . Through test-suite reduction, we also produce HUMANEVAL+-MINI which distills HUMANEVAL+ tests by $4 7 \\times$ while still achieving a similar level of testing effectiveness. Our extensive evaluation over 26 popular LLMs surprisingly finds that the pass $@ k$ on the new dataset is up-to $1 9 . 3 \\substack { - 2 8 . 9 \\% }$ (for different $k s$ ) lower than the base HUMANEVAL, showing that testing insufficiency can largely affect the result analysis for almost all recent work on LLM-based code generation. Meanwhile, on the original HUMANEVAL both of the 34B WizardCoder-CodeLlama [38] and Phind-CodeLlama [52] models are deemed to be no better than ChatGPT, while HUMANEVAL+ corrected the ranking and shows that the two open-source models are actually better. Additionally, we even found that the ground-truth solutions of HUMANEVAL can be erroneous, further calling into question the quality of code synthesis benchmarks. ",
+        "bbox": [
+            174,
+            585,
+            826,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Approach ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            756,
+            287,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 shows the overview of EvalPlus. We first take in as input the original dataset containing the ground-truth implementation as well as the base test inputs. EvalPlus starts with constructing a prompt using the original ground-truth, exemplary test inputs as demonstration, and a specialized instruction to query ChatGPT and generate a set of high-quality seed inputs. ChatGPT, by following base input formats and inspecting the ground-truth solution, can serve as a vehicle to generate valid yet rigorous test inputs. Starting from these seed inputs, we then perform type-aware mutation to quickly generate numerous new inputs together with seed inputs to extensively evaluate the functional correctness of LLM-generated code. We use differential testing [40] as the oracle to cross-check the output of the ground-truth and LLM-generated solution. As an option to speed up evaluation, EvalPlus runs set covering to minimize the generated test-suite while preserving the same level of testing effectiveness. As the final output, EvalPlus obtains a augmented benchmark using the generated high-quality test inputs to fully evaluate the functional correctness of LLM-synthesized code. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/0d86d1f7a45824883ce939648eb3da8329fb26ede147f8dfedb808ed03d7226a.jpg",
+        "table_caption": [
+            "Table 1: List of basic type-aware mutations over input $x$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Type</td><td>Mutation</td><td>Type</td><td>Mutation</td></tr><tr><td>int|float</td><td>Returns x±1</td><td>List</td><td>Remove/repeat a random item x[i] Insert/replace x[i] with Mutate(x[i])</td></tr><tr><td>bool</td><td>Returns a random boolean</td><td>Tuple</td><td>Returns Tuple(Mutate(List(x)))</td></tr><tr><td>NoneType</td><td>Returns None</td><td>Set</td><td>Returns Set(Mutate(List(x)))</td></tr><tr><td>str</td><td>Remove a sub-string s Repeat a sub-string s Replace s with Mutate(s)</td><td>Dict</td><td>Remove a key-value pair k→ U Update k -→v to k-→Mutate(u) Insert Mutate(k)→Mutate(u)</td></tr></table>",
+        "bbox": [
+            187,
+            109,
+            808,
+            233
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            281,
+            825,
+            324
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 Automated Test Input Generation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            444,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Seed initialization via ChatGPT. EvalPlus first uses ChatGPT to generate a set of high-quality seed inputs for later mutation. Following Figure 2, we construct a prompt using $( i )$ the ground-truth solution of the problem for ChatGPT to inspect; (ii) a set of test inputs as demonstration; and (iii) an instruction to encourage ChatGPT to come up with interesting inputs. Specifically, each prompt starts with the ground-truth implementation and then randomly sampled test inputs from the existing dataset. We then finalize the prompt with a selected instruction in Figure 2 and query ChatGPT to produce new inputs. EvalPlus aims to leverage the powerful understanding ability of ChatGPT to learn both the valid input formats (e.g., variable types) as well as the desired functionality of the ground-truth solution in order to produce meaningful test inputs to reveal bugs in incorrectly synthesized code. Programs can have their own expected input formats, where invalid inputs should not be passed into the function as they can incur undefined behaviors to create false-positives in differential testing. As such, we filter out any invalid inputs which violate the input precondition required by the ground-truth implementation. ",
+        "bbox": [
+            173,
+            404,
+            825,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By using ChatGPT as an automated generation engine, we can generate inputs that are valid even under semantic constraints. For example, a programming problem may require the input to conform to a specific structure (e.g., a palindrome). Such semantic constraints can be extremely difficult for traditional input generators to satisfy. However, ChatGPT is unsuitable for large amounts of automated test generation due to undesired speed and cost of querying such a large model. To address this, we perform type-aware input mutation starting from high-quality seed inputs generated by ChatGPT. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            661
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Type-aware input mutation. We follow a typical mutation-based fuzzing workflow [74, 57] to continuously create inputs: (i) a corpus of seed inputs from ChatGPT are used to initialize the seed pool and bootstrap the generation pipeline; (ii) each time an input (i.e., seed) from the seed pool is randomly selected to be mutated to a new input (i.e., mutant); and (iii) new inputs that comply with the program contract (§2.3) are added to the seed pool and we start over from (ii) to continue the generation process. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            739
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To efficiently create more valid inputs, we leverage type-aware mutation [66] in step (ii) which inspects the data types of the incoming valid seeds and generates new inputs that are structurally similar to the seeds. In Table 1 we illustrate the basic mutations used for different types of inputs. For simple primitive types such as int and float, the mutation is as simple as incrementing/decrementing the value. For compound types and the string type (i.e., str), besides generally removing or repeating existing elements (or sub-strings for str), the elements and sub-strings can be mutated recursively according to their inner types. Such sub-mutants can then be used to replace existing items or add new items in a finer-grain manner. In addition, to alleviate generating inputs that violate subtle semantic constraints, following [23, 34], we additionally apply an ingredient mechanism to collect appeared data fragments and reuse them during mutation. In short, type-aware input mutation builds on the high-quality seed inputs produced by ChatGPT to generate large amounts of test inputs which we use as the final set of extensive test inputs to evaluate LLM-synthesized code. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 Test-Suite Reduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            356,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "While the large number of newly generated tests in EvalPlus are effective in detecting incorrect code, the test execution can be costly. As an option to more efficiently evaluate LLM-generated code, we further investigate test-suite reduction strategies [75, 59], which aim to select a subset of the original test-suite while still maintaining the original test effectiveness. To perform test reduction, it is typically assumed that each test can fulfill a set of testing requirements. The problem can then be formalized as reducing the original test-suite $\\tau$ into $\\mathcal { T } _ { r e d }$ , such that $\\forall r \\in \\mathcal { R }$ ( $\\exists t \\in \\tau$ , $t$ satisfies $r \\implies \\exists t ^ { \\prime } \\in$ $\\mathcal { T } _ { r e d } , t ^ { \\prime }$ satisfies $r$ ). In other words, any testing requirement $r$ satisfied by the original test-suite should still be satisfied by the reduced one. Finding such minimal representative subset for a given test-suite is equivalent to the set covering problem [17]. To solve this problem effectively, it is crucial to define the testing requirements accurately. In this paper, we focus on the following types of requirements: ",
+        "bbox": [
+            174,
+            119,
+            825,
+            260
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Code coverage: Code coverage [24] measures the amount of code elements (e.g., statements or branches) executed by each test, and has been widely used in practice to measure test effectiveness. In this strategy, following traditional test-suite reduction [53] we leverage the widely used branch coverage as the testing requirement. In other words, the goal of using this metric is to only preserve a minimal subset of tests which can cover the same set of branches as the full tests. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Mutant killings: Coverage measures the extent to which the code has been executed; however, a high-coverage test-case is not necessarily effective in finding critical defects in its covered code. Consequently, researchers have proposed mutation testing [7] (also known as mutation analysis) to more precisely evaluate test effectiveness. In short, mutation testing applies a set of predefined mutation rules (e.g., changing $\" < \"$ and $\\ \" \\leq \\ \" \\}$ ) to the program under test (i.e., the ground-truth solutions for this case) to create a large number of artificial buggy programs, each of which is called as a mutant and includes exactly one subtle bug seeded. In this way, the ratio of mutation bugs detected by the tests (also called killed) can be used to assess the test effectiveness. In fact, studies have shown that mutation testing can largely outperform code coverage in test effectiveness evaluation [51]. Following prior work [59], we also leverage the set of mutants killed by each test as our testing requirement. Consequently, the goal is to minimize the number of tests while still being able to detect the same set of mutation bugs. ",
+        "bbox": [
+            173,
+            347,
+            826,
+            500
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "LLM sample killings: Different LLMs could fail commonly over certain test-cases. Consequently, besides these theoretical metrics, we also use as a testing requirement by empirically looking at sample killings, i.e., the set of wrong LLM samples that a test-case can detect and falsify. Of course, for a new LLM under evaluation, we do not have any test execution results for its code samples. Therefore, we only use the execution results for samples generated by other LLMs to evaluate test effectiveness for reduction (i.e., leave-one-out cross validation [22]). As such, we minimize the number of tests while making sure that all incorrect samples synthesized by other models can be detected by the reduced test-suite. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            618
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Besides the above three strategies, we also investigate another strategy that merges all three testing requirements for reduction. That is, the goal is to minimize the number of tests while still maintaining the same branch coverage, mutant killing, and incorrect sample detection results. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 Program Input Contracts ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            390,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The goal of evaluating code synthesis is to check whether the synthesized code accurately reflects the desired user intent. This is done by using several test inputs and comparing the output of the generated code against that of the ground-truth solution. The prior sections demonstrated how to improve the test inputs used to more rigorously evaluate the synthesized code. However, these user intents (expressed as natural language docstring) can be too vague for LLMs to follow. As such, LLMs might allow for different interpretations of the desired functionality, input formats as well as how to handle corner cases. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            809
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To this end, we adopt a programming by contract [41] philosophy by systematically annotating function pre-conditions in form of code assertions (e.g., assert $\\mathbf { n } > 0$ ), to ensure the test inputs for the function are well-formed. The benefits of the contracts are two-fold: $( i )$ they can complement the automatic input generation steps to filter out any generated invalid inputs that violate the contracts. Such ill-formed inputs can incur undefined behaviors which are unreasonable to use for evaluating LLM-synthesized code; and (ii) they can serve as orthogonal descriptors together with the natural language description in the prompt for further clarification. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/0766cd8778069d3193cfa23f5d7a6038d88761a8e4ab3af3d5cf588eceb2b772.jpg",
+        "table_caption": [
+            "Table 2: Overview of EvalPlus-improved benchmarks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"4\">#Tests</td><td rowspan=\"3\">#Tasks</td></tr><tr><td>Avg.</td><td>Medium</td><td>Min.</td><td>Max.</td></tr><tr><td>HUMANEVAL</td><td>9.6</td><td>7.0</td><td>1</td><td>105²</td><td rowspan=\"3\">164</td></tr><tr><td>HUMANEVAL+</td><td>764.1</td><td>982.5</td><td>12</td><td>1,100</td></tr><tr><td>HUMANEVAL+ -MINI</td><td>16.1</td><td>13.0</td><td>5</td><td>110</td></tr></table>",
+        "bbox": [
+            284,
+            109,
+            715,
+            198
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            227,
+            295,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Setup. Our evaluation focuses on using the unbiased version of $\\operatorname { p a s s } @ k$ [11] to accurately assess the functional correctness of LLM-synthesized code. For generalizability, we conducted a comprehensive evaluation over 26 popular and state-of-the-art LLMs and a wide range of temperature settings. Specifically, following prior work [11, 46], for each model we perform: $( i )$ random sampling to generate 200 program samples for each of the four temperature settings $( \\{ 0 . 2 , 0 . 4 , 0 . 6 , 0 . \\bar { 8 } \\} )$ ; and $( i i )$ greedy-search decoding. For random sampling, we show the best-performing pass $@ k$ for each $k \\in \\mathsf { \\bar { \\{ 1 , 1 0 , 1 0 0 \\} } }$ and its corresponding temperature denoted by $T _ { k } ^ { * }$ . For greedy decoding, we only synthesize one deterministic sample for each task and evaluate its pass rate as pass $@ 1 ^ { \\star }$ . By default we evaluate models under both setting $( i )$ and $( i i )$ , except for the two commercial models due to time and cost constraints: GPT-4 is only evaluated under greedy decoding, and ChatGPT is additionally evaluated on 0.8-temperature random sampling. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While EvalPlus is general, this paper focuses on evaluating its effectiveness on HUMANEVAL [11], one of the most widely-used datasets for code generation3. HUMANEVAL consists of 164 humanwritten programming tasks, each of which provides a Python function signature and a docstring as the input to the LLM. Based on the input, LLMs complete a solution whose functional correctness is judged by a handful of manual test-cases (the first row in Table 2). As such, EvalPlus transforms HUMANEVAL to HUMANEVAL+ by adding $8 0 \\times$ unique test-cases and fixing incorrect ground-truth solutions in HUMANEVAL. Specifically, for each task, based on around 30 ChatGPT-generated seed inputs which are produced using 3 separate prompts, we run type-aware mutation to generate 1000 additional inputs using one-hour budget. In HUMANEVAL+, 83 out of the 164 programming tasks are annotated with hand-crafted contracts. Because EvalPlus requires ground-truth solutions to cross-check LLM-generated code, it is crucial to ensure the correctness of the ground-truths. However, by inspecting ground-truths in the original HUMANEVAL, we found over $10 \\%$ of them are incorrectly implemented. Therefore, as another contribution we carefully re-implemented and tested all ground-truths for HUMANEVAL+. As an option to speed up evaluation, we build HUMANEVAL+-MINI which is minimized from HUMANEVAL+ (smaller by $4 7 \\times$ ) yet preserves similar test effectiveness on the studied models. Lastly, more experimental setups are detailed in Appendix. ",
+        "bbox": [
+            173,
+            424,
+            825,
+            645
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation of LLMs. Table 3 shows the pass $@ k$ when evaluating LLMs using both the base HUMANEVAL and HUMANEVAL+. We first observe that across all LLMs, models sizes and $k$ values, using HUMANEVAL+, almost all pass $@ k$ results consistently drop compared to using the base HUMANEVAL. Notably, the performance drop is significant with up-to $2 3 . 1 \\%$ $( \\mathrm { p a s s } @ 1 ^ { \\star } )$ / $1 9 . 3 \\%$ (pass $@ 1$ ) $/ 2 4 . 9 \\%$ (pass $@ 1 0$ ) $/ 2 8 . 9 \\%$ (pass $@ 1 0 0 _ { , }$ ) reduction over the evaluated models. Such performance decrease is not only seen in popular open-source LLMs, such as the widely used CodeGen-16B [46] $( 1 8 . 5 \\%$ reduction) as well as the emerging CODELLAMA-34B [54] $( 1 7 . 6 \\% )$ and StarCoder [13] ( $1 4 . 1 \\%$ reduction), but also observed in state-of-the-art commercial ChatGPT $( 1 2 . 6 \\%$ reduction) and GPT-4 $2 3 . 1 \\%$ reduction) models. Overall, our results overall confirm our hypothesis that the prior evaluation on HUMANEVAL is not robust enough to detect wrong code synthesized by LLMs. Not only are these LLMs widely used for daily programming but they also serve as common reference points for evaluating new code synthesis techniques. As such, evaluating on a more robust benchmark such as HUMANEVAL+ is highly recommended in order to draw precise conclusions. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/832775e6d1c9cba765f7c3cb407f1118b062d5b77a5f9bf2e396351cb69060e6.jpg",
+        "table_caption": [
+            "Table 3: Evaluating LLMs on HUMANEVAL and HUMANEVAL+. All models, except for INCODER, CodeGen2, StarCoder and SantaCoder which perform infilling, use auto-regressive generation. $k { = } 1 ^ { \\star }$ marks pass $@ 1$ done with greedy decoding. $T _ { k } ^ { * }$ denotes the optimal pass $@ k$ temperature. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Size pass@k</td><td>k=1*</td><td>k=1</td><td>k=10</td><td>k=100</td><td></td><td>T</td><td>T0</td><td>T100</td></tr><tr><td>GPT-4 [49]</td><td>N/A</td><td>base +extra</td><td>88.4 76.2</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Phind-CodeLlama [52]</td><td>34B</td><td>base</td><td>71.3</td><td>71.6</td><td>90.5</td><td>96.2</td><td>2</td><td>.8</td><td>.8</td></tr><tr><td>WizardCoder-CodeLlama [38]</td><td>34B</td><td>+extra base</td><td>67.1 73.2</td><td>67.0 61.6</td><td>85.0 85.2</td><td>92.5 94.5</td><td>2</td><td>.8 .8</td><td>.8 .8</td></tr><tr><td></td><td>N/A</td><td>+extra base</td><td>64.6 73.2 69.4</td><td>54.5</td><td>78.6 88.6</td><td>88.9 94.0</td><td></td><td>.8</td><td>.8</td></tr><tr><td>ChatGPT [48]</td><td>34B</td><td>+extra</td><td>63.4 51.8</td><td>62.5 52.0</td><td>82.1</td><td>91.1</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td rowspan=\"3\">CODELLAMA [54]</td><td rowspan=\"3\">13B</td><td>base +extra</td><td>42.7 43.1</td><td></td><td>82.4</td><td>95.0</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>base</td><td>42.7 44.6</td><td></td><td>73.7 77.6</td><td>89.4</td><td>.4</td><td>.8</td><td>.8</td></tr><tr><td> +extra</td><td>36.6 37.4</td><td>69.4</td><td></td><td>92.7 88.2</td><td>.4</td><td>.8</td><td>.8</td></tr><tr><td></td><td>7B</td><td>base</td><td>37.8</td><td>39.2 69.1</td><td></td><td>89.7</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>StarCoder [13]</td><td>15B</td><td>+extra base</td><td>34.1 34.1</td><td>34.5 32.2</td><td>61.4 56.7</td><td>82.9 84.2</td><td>.2 .2</td><td>.8</td><td>.8 .8</td></tr><tr><td></td><td>16B</td><td>+extra base</td><td>29.3 32.9</td><td>27.8 32.2 56.0</td><td>50.3</td><td>75.4 81.5</td><td>.2 .2</td><td>.8 .6</td><td>.8 .8</td></tr><tr><td rowspan=\"3\">CodeGen [46]</td><td rowspan=\"2\">6B</td><td> +extra</td><td>26.8 29.3</td><td>27.2 48.4</td><td></td><td>71.4 .2</td><td>.2</td><td>.6 .6</td><td>.8 .8</td></tr><tr><td>base +extra</td><td>27.7 25.6</td><td>46.9</td><td></td><td>72.7</td><td>.2</td><td>.6</td><td>.8</td></tr><tr><td>base</td><td></td><td>23.6 18.4</td><td>41.0</td><td>64.6</td><td></td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>CODET5+ [64]</td><td>2B</td><td>+extra</td><td>24.4 20.7</td><td>15.1</td><td>39.8 34.8</td><td>66.8 55.8</td><td>.2</td><td>2</td><td>.8</td></tr><tr><td></td><td>16B</td><td>base +extra</td><td>31.7 26.2</td><td>32.2 27.4</td><td>58.5 51.1</td><td>83.5</td><td>2</td><td>.6 .6</td><td>.8 .8</td></tr><tr><td>MISTRAL [26]</td><td>7B</td><td>base +extra</td><td>28.7 23.8</td><td>28.1</td><td>55.2</td><td>76.4 83.8</td><td>2</td><td></td><td>.8 .8</td></tr><tr><td rowspan=\"4\">CodeGen2 [45]</td><td rowspan=\"2\">16B4</td><td>base</td><td>19.5</td><td>23.7</td><td>48.5</td><td>76.4</td><td></td><td></td><td></td></tr><tr><td> +extra</td><td>16.5</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>7B</td><td>base +extra</td><td>18.3</td><td>17.9 30.9</td><td></td><td>50.9</td><td>2.2.2.2.</td><td>.6 .6</td><td>.8 .8</td></tr><tr><td>3B</td><td>base</td><td>16.5 15.9</td><td>15.9 15.2</td><td>27.1 23.9</td><td>45.4 38.6</td><td></td><td>.4</td><td>.8</td></tr><tr><td rowspan=\"3\"></td><td rowspan=\"2\">1B</td><td> +extra</td><td>12.8</td><td>12.9 21.2</td><td>34.3</td><td></td><td>.2</td><td>.4 .6</td><td>.8 .6</td></tr><tr><td>base</td><td>11.0</td><td>10.2 15.1</td><td></td><td>24.7</td><td>.2</td><td>.6</td><td>.6</td></tr><tr><td>+extra</td><td></td><td>9.1 8.7</td><td>13.7</td><td>21.2</td><td></td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td rowspan=\"2\">VICUNA [12]</td><td rowspan=\"2\">13B</td><td>base +extra</td><td>16.5 15.2</td><td>15.3 13.9</td><td>30.1 25.8</td><td>54.8</td><td>.2</td><td>.8</td><td>.8</td></tr><tr><td>base</td><td>11.6</td><td>10.9</td><td>23.8</td><td>46.7 42.3</td><td>.2 .2</td><td>.6</td><td>.6</td></tr><tr><td>SantaCoder [2]</td><td>7B</td><td>+extra</td><td>11.0</td><td>10.3</td><td>20.3</td><td>35.0</td><td>.4</td><td>.6 .6</td><td>.6 .8</td></tr><tr><td rowspan=\"2\"></td><td rowspan=\"2\">1.1B</td><td>base +extra</td><td>14.6 12.8</td><td>16.6 14.2</td><td>29.2</td><td>45.4 40.6</td><td>.4</td><td>.6</td><td>.8</td></tr><tr><td></td><td>15.9</td><td>26.2 27.7</td><td></td><td>45.0</td><td>.2</td><td>.4</td><td>.6</td></tr><tr><td rowspan=\"3\">INCODER [18]</td><td rowspan=\"2\">6.7B</td><td>base</td><td>12.2</td><td>15.6</td><td></td><td></td><td>.2</td><td>.6</td><td>.6</td></tr><tr><td>+extra base</td><td>12.2</td><td>12.4 10.0</td><td>22.2 15.9</td><td>38.9 25.2</td><td>.2 .2</td><td>.6</td><td>.6</td></tr><tr><td>1.3B</td><td>+extra</td><td>10.4 7.9</td><td>13.5</td><td>20.7</td><td></td><td></td><td>.6</td><td>.4</td></tr><tr><td rowspan=\"2\">GPT-J[63]</td><td rowspan=\"2\">6B</td><td>base</td><td>12.2</td><td>11.3</td><td>17.7</td><td>31.8</td><td>.2 .2</td><td>.6</td><td>.6</td></tr><tr><td>+extra</td><td>10.4</td><td>9.5 15.2</td><td></td><td>25.9</td><td></td><td>.6</td><td>.6</td></tr><tr><td>GPT-NE0 [5]</td><td>2.7B</td><td>base</td><td>7.9</td><td>6.5</td><td>11.8</td><td>20.7</td><td>.2 .2</td><td>.6 .6</td><td>.6 .6</td></tr><tr><td rowspan=\"2\"></td><td rowspan=\"2\"></td><td>+extra</td><td>6.7</td><td>6.0</td><td>9.0</td><td>16.8 17.1</td><td></td><td></td><td>.6</td></tr><tr><td>base</td><td>6.1</td><td>5.9 10.2</td><td></td><td></td><td>2</td><td>.4</td><td>.6 .6</td></tr><tr><td rowspan=\"2\">PolyCoder [70] StableLM[60]</td><td rowspan=\"2\">2.7B 7B</td><td>+extra base</td><td>5.5 2.4</td><td>5.3 2.7</td><td>7.9 7.5</td><td>13.6 15.8</td><td>.2 .2</td><td>.6 .6</td></table>",
+        "bbox": [
+            173,
+            172,
+            833,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6b6cc5aa645c66af6d0434a94d8daea1665cfcd62f2923a127eecab0178bfe06.jpg",
+        "table_caption": [
+            "Table 4: Reduced test-suite for HUMANEVAL+. We first show the pass $@ 1 ^ { \\star }$ and average #tests (including base HUMANEVAL tests) by only doing set covering over each considered metric separately (§2.2). The Full column then shows the final reduction result by combining all of the three. For reference, the average #tests of original HUMANEVAL and HUMANEVAL+ are 9.6 and 774.8 respectively (Table 2). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Size</td><td colspan=\"2\">Coverage</td><td colspan=\"2\">Killed mutants</td><td colspan=\"2\">Killed samples</td><td colspan=\"2\">Full</td><td colspan=\"2\">Ref. pass@1*</td></tr><tr><td>pass@1*</td><td>#tests</td><td>pass@1*</td><td>#tests</td><td>pass@1*</td><td>#tests</td><td>pass@1*</td><td>#tests</td><td>base</td><td>+extra</td></tr><tr><td>GPT-4</td><td>N/A</td><td>86.0</td><td>11.3</td><td>82.9</td><td>11.4</td><td>78.7</td><td>13.8</td><td>78.0</td><td>16.1</td><td>88.4</td><td>76.2</td></tr><tr><td>ChatGPT</td><td>N/A</td><td>71.3</td><td>11.3</td><td>69.5</td><td>11.4</td><td>65.2</td><td>13.7</td><td>65.2</td><td>16.0</td><td>73.2</td><td>63.4</td></tr><tr><td>StarCoder</td><td>15B</td><td>32.9</td><td>11.3</td><td>32.9</td><td>11.4</td><td>29.3</td><td>13.6</td><td>29.3</td><td>15.9</td><td>34.1</td><td>29.3</td></tr><tr><td rowspan=\"3\">CodeGen</td><td>2B</td><td>23.2</td><td>11.3</td><td>23.8</td><td>11.4</td><td>21.3</td><td>13.2</td><td>21.3</td><td>15.4</td><td>24.4</td><td>20.7</td></tr><tr><td>6B</td><td>28.7</td><td>11.3</td><td>29.3</td><td>11.4</td><td>25.6</td><td>13.2</td><td>25.6</td><td>15.4</td><td>29.3</td><td>25.6</td></tr><tr><td>16B</td><td>31.7</td><td>11.3</td><td>31.1</td><td>11.4</td><td>27.4</td><td>13.2</td><td>27.4</td><td>15.4</td><td>32.9</td><td>26.8</td></tr><tr><td rowspan=\"4\">CodeGen2</td><td>1B</td><td>10.4</td><td>11.3</td><td>11.0</td><td>11.4</td><td>9.1</td><td>13.8</td><td>9.1</td><td>16.0</td><td>11.0</td><td>9.1</td></tr><tr><td>3B</td><td>15.9</td><td>11.3</td><td>15.9</td><td>11.4</td><td>12.8</td><td>13.8</td><td>12.8</td><td>16.0</td><td>15.9</td><td>12.8</td></tr><tr><td>7B</td><td>18.3</td><td>11.3</td><td>18.3</td><td>11.4</td><td>16.5</td><td>13.8</td><td>16.5</td><td>16.0</td><td>18.3</td><td>16.5</td></tr><tr><td>16B</td><td>19.5</td><td>11.3</td><td>18.9</td><td>11.4</td><td>16.5</td><td>13.8</td><td>16.5</td><td>16.0</td><td>19.5</td><td>16.5</td></tr><tr><td rowspan=\"2\">VICUNA</td><td>7B</td><td>11.6</td><td>11.3</td><td>11.6</td><td>11.4</td><td>11.0</td><td>13.8</td><td>11.0</td><td>16.1</td><td>11.6</td><td>10.4</td></tr><tr><td>13B</td><td>16.5</td><td>11.3</td><td>16.5</td><td>11.4</td><td>15.2</td><td>13.8</td><td>15.2</td><td>16.1</td><td>17.1</td><td>15.2</td></tr><tr><td rowspan=\"2\">SantaCoder</td><td>1.1B</td><td>14.6</td><td>11.3</td><td>14.6</td><td>11.4</td><td>12.8</td><td>13.8</td><td>12.8</td><td>16.1</td><td>14.6</td><td>12.8</td></tr><tr><td>1.3B</td><td>12.2</td><td>11.3</td><td>12.2</td><td>11.4</td><td>10.4</td><td>13.6</td><td>10.4</td><td>16.0</td><td>12.2</td><td>10.4</td></tr><tr><td rowspan=\"2\">INCODER GPT-J</td><td>6.7B</td><td>14.6</td><td>11.3</td><td>14.6</td><td>11.4</td><td>12.2</td><td>13.6</td><td>12.2</td><td>16.0</td><td>15.9</td><td>12.2</td></tr><tr><td>6B</td><td>12.2</td><td>11.3</td><td>12.2</td><td>11.4</td><td>10.4</td><td>13.8</td><td>10.4</td><td>16.0</td><td>12.2</td><td>10.4</td></tr><tr><td>GPT-NEO</td><td>2.7B</td><td>7.3</td><td>11.3</td><td>7.3</td><td>11.4</td><td>6.7</td><td>13.8</td><td>6.7</td><td>16.1</td><td>7.9</td><td>6.7</td></tr><tr><td>PolyCoder</td><td>2.7B</td><td>6.1</td><td>11.3</td><td>6.1</td><td>11.4</td><td>5.5</td><td>13.8</td><td>5.5</td><td>16.1</td><td>6.1</td><td>5.5</td></tr><tr><td>StableLM</td><td>7B</td><td>2.4</td><td>11.3</td><td>2.4</td><td>11.4</td><td>2.4</td><td>13.8</td><td>2.4</td><td>16.1</td><td>2.4</td><td>2.4</td></tr></table>",
+        "bbox": [
+            186,
+            151,
+            813,
+            444
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also show that a more rigorous evaluation could yield different or totally contradictory relative results. For example, WizardCoder-CodeLlama and Phind-CodeLlama on the original HUMANEVAL are evaluated to be no better than ChatGPT in terms of pass $@ 1 ^ { \\star }$ . However, HUMANEVAL+ demonstrates that the two open-source models can actually outperform the proprietary ChatGPT. Other contrary examples reflected by HUMANEVAL+ include that SantaCoder-1B surpasses INCODER-6.7B and VICUNA-7B outperforms INCODER-1.3B. Table 3 further illustrates the distribution of best-performing temperatures over different $k$ values. Our results conforms with prior findings [11] that a lower temperature tends to perform better for smaller $k$ , while a higher temperature works better for larger $k$ . We also observe that the optimal temperatures seem to stay fairly consistent before and after using HUMANEVAL+; however, slight differences still exist, e.g., best temperature for CodeGen-2B on pass $@ 1 0$ becomes 0.2 from 0.8 after using HUMANEVAL+. Nonetheless, this motivates future research to look more closely on the effect of temperature with respect to the robustness of the evaluation tests, esp. those edge-cases. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effectiveness of test-suite reduction. Based on HUMANEVAL+ which on average obtains 764.1 tests for each programming task (Table 2), our test-suite reducer $( \\ S 2 . 2 )$ minimizes it to HUMANEVAL+- MINI which only has 16.1 tests for each task (smaller by $4 7 \\times$ ). Table 4 performs leave-one-out cross validation to show the pass $@ 1 ^ { \\star }$ differences over a subset of representative models studied in Table 3 (due to time/space constraints). That is, for each evaluated LLM we construct the reduced test-suite without considering its own sample kills. The Full column shows that the reduced test-suite can achieve almost the same pass $@ 1 ^ { \\star }$ drop as HUMANEVAL+ by only using $4 7 \\times$ fewer test-cases. Taking a closer look, separately performing set covering over each metric can harness the pass $@ 1 ^ { \\star }$ of the base HUMANEVAL to certain degree. Specifically, the use of empirical LLM sample killings is the most effective, leading to the same effectiveness as the full approach, but also consumes more tests than other theoretical metrics. While using coverage and mutation analysis seems to be unnecessary in addition to using sample killings, they still serve as the base guarantees for the theoretical test adequacy. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Pass rate distribution. Figure 3 shows for each programming task the overall pass rates on HUMANEVAL and HUMANEVAL+ tests. The pass rate gap between HUMANEVAL and HUMANEVAL+ shows overall HUMANEVAL+ can detect solutions that are misidentified by HUMANEVAL for problems of all levels of difficulties. We also observe that problems in HUMANEVAL are not equal, not only in terms of problem difficulty but also the difficulty of generating counter-examples and edge-cases to deeply exercise LLM-generated code. For simple problems such as “adding two numbers” and “length of a string” (i.e., problems with top-2 pass rates), it is easy to solve for LLMs and to test manually. While problems dealing with multiple conditions (e.g., “word splitting”), completeness (e.g., handling negative numbers for “is-prime”) , reasoning ability (e.g., “Tribonacci sequence”) and efficiency requirements (e.g., “n-th prime Fibonacci number”) are the hardest tasks to the evaluated LLMs, positioning future research to improve LLMs for conquering such coding skills. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8957033a3d75d416829c6f5be232a3f78cb93a579c8114a591c0782819eac96d.jpg",
+        "image_caption": [
+            "Figure 3: Pass rate distribution. X-axis spans bars for all 164 problems, sorted by the HUMANEVAL pass rate. Y-axis shows the log-scale pass rates averaged by all LLM-generated samples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            92,
+            769,
+            224
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            292,
+            825,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Incorrect “ground-truth” in HUMANEVAL. In addition to detecting wrong code from LLMs using EvalPlus, we also found 18 defects ( $1 1 \\%$ of problems) even in the original ground-truth in HUMANEVAL, including (i) Unhandled edge-case: five prior ground-truths fail to handle corner-case inputs (e.g., empty list or string); (ii) Bad logic: 10 prior ground-truths incorrectly implement the desired functionality; and (iii) Performance issue: three inefficient implementations lead to slow performance on reasonably-sized inputs. Among those, bad logic (10) is the most serious as the original “groundtruth” does not accurately reflect the user intent. Such defects are detected also through differential testing but between our own re-implemented ground-truth and the original ground-truth in HUMANEVAL. ",
+        "bbox": [
+            174,
+            386,
+            826,
+            497
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/343bed10bdc118b6c4dec60fa0c9e6e3926d4db9f0838f1b97fa215f9f8ee865.jpg",
+        "image_caption": [
+            "Figure 4: Exemplary incorrect-logic ground-truth solution in HUMANEVAL (#124) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            510,
+            779,
+            587
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows an incorrect ground-truth implementation (validate_date) from HUMANEVAL classified as having bad logic. The desired task is to check if the input date format is correct. We see that in the core logic, the conditions attempt to first check the month condition and then handle the corresponding day conditions. However, this is implemented incorrectly as “and” in Python5 has higher precedence than “or”, leading to the ground-truth function to check if either conditions satisfies instead of the desired both conditions must satisfy. This is exposed via our automatically generated test input of 12-31-1999 where the ground-truth implementation incorrectly labels this as not a valid date. Surprisingly this egregious error is not exposed by any of the base test inputs in HUMANEVAL, further demonstrating the weakness and limited evaluation power of the original test inputs. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            770,
+            320,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "LLMs for code. The use of LLMs for code has gained traction in recent years, owing to the abundance of open codebase and the need for improving developer efficiency. LLMs have demonstrated state-of-the-art performance on various code-related tasks, including code generation [11, 33, 25], program repair [69, 27, 68, 65], automated testing [15, 14, 67, 35, 71], code translation [31, 55] and code summarization [1, 37]. In particular, prominent LLMs including CODEX [11], CodeGen [46], INCODER [18] and PolyCoder [70], have been developed and extensively evaluated for code generation (widely recognized as the holy grail for computer science research since the inception of AI in the 1950s [21]), where the model generates code snippets based on natural language descriptions (e.g., docstring) of the desired functionality. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            92,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Coding benchmark for LLMs. LLM-based code synthesis is largely evaluated based on functional correctness, which is typically assessed by running test-cases to check the desired outputs. HUMANEVAL [11] is one of the pioneering and most widely studied human-written benchmarks for LLM-based code synthesis, consisting of 164 pairs of Python function signature with docstring and the associated test-cases for correctness checking. Additionally, each HUMANEVAL problem is also equipped with a reference solution. Another Python-focused dataset, MBPP [3], is created by crowd-sourcing participants to write in summation 974 programming problems, each of which is comprised of the problem statement (i.e., docstring), the function signature, as well as three test-cases. Beyond Python, there are other benchmarks targeting additional languages such as Spider [73] (SQL), HUMANEVAL-X [76] $^ { ( \\mathrm { C + + } }$ , Javascript and Go), CodeContests [33] ( $\\scriptstyle ( + +$ and Java) and MultiPL-E [9] (extending HUMANEVAL and MBPP to 18 programming languages). More recently, researchers have created a more realistic code synthesis benchmark by collecting GitHub issues along with the corresponding code base together with tests to measure the ability of LLMs to perform real-world software engineering tasks [28]. Our work shows for the first time the test inadequacy problem of widely studied benchmarks and addresses the issue via automatic test generation. ",
+        "bbox": [
+            174,
+            142,
+            825,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Automated test generation. Automated test generation is a widely used for finding software bugs with automatically generated tests. Black-box test generation such as fuzz testing [43] feeds random inputs (e.g., random bytes) to the system under test (SUT), without knowing its source code. Traditional black-box techniques can mainly be categorized into generation-based [72, 23, 56] and mutationbased [66, 10, 47] ones. White-box approaches provide better-quality test-cases by analyzing the source code of SUT. For instance, symbolic execution [30, 8] breaks the coverage plateaus by solving symbolic path constraints to generate tests targeting deep paths. As a mid-point, coverage-guided fuzzing [74, 57] (i.e., grey-box) uses the coverage information of SUT as feedback to adjust the input generation and mutation. The discussed traditional methods are inapplicable to generating semantically meaningful inputs for arbitrary problems programmed in a dynamically-typed language. We address this by using ChatGPT to inspect the ground-truth (i.e., white-box) for initializing interesting seeds, based on which type-aware mutation (i.e., black-box) scales the test inputs to a large amount. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            525
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion & Future Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            431,
+            561
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We present EvalPlus – a rigorous evaluation framework for program synthesis, driven by automated test generation. EvalPlus combines both LLM- and mutation-based input generation to obtain a diverse set of test inputs for accurately evaluating the correctness of LLM-generated code. EvalPlus creates HUMANEVAL+, built on top of the popular HUMANEVAL with additional high-quality and automatically generated test inputs. With test-suite reduction, EvalPlus also produces HUMANEVAL+-MINI which is smaller than HUMANEVAL+ by $4 7 \\times$ while preserving similar test effectiveness. We extensively evaluate a diverse set of LLMs and show that HUMANEVAL+ can identify a significant amount of previously undetected wrong code generated by LLMs, demonstrating its effectiveness to augment programming benchmarks for more accurate evaluation. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Since launched, the EvalPlus PyPI package has been installed by over 6k times in 5 months. We also keep evaluating new models for code and maintain a leaderboard at https://evalplus.github. io/leaderboard.html. In the future, we plan to apply EvalPlus to bring better-quality testing for more code benchmarks such as MBPP. Meanwhile. future work can look into how to integrate EvalPlus with more formal verification (e.g., Dafny [32]) or validation techniques (e.g., translation validation [36]) to provide stronger guarantees of the evaluation results when applicable. Additionally, the core test generation technique behind can be even used to remind developers of potential flaws of the accepted LLM-generated code snippets when doing AI pair-programming (e.g., Copilot [42]). ",
+        "bbox": [
+            174,
+            707,
+            825,
+            818
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            367,
+            854
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was partially supported by NSF grants CCF-2131943 and CCF-2141474, as well as Kwai Inc. We thank the reviewers for their invaluable feedback. We further thank Yinlin Deng for providing helpful discussions, as well as Junhao Wang and Songrun Xie for their open-source contributions. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] T. Ahmed and P. Devanbu. Few-shot training llms for project-specific code-summarization. In 37th IEEE/ACM International Conference on Automated Software Engineering, pages 1–5, 2022.   \n[2] L. B. Allal, R. Li, D. Kocetkov, C. Mou, C. Akiki, C. M. Ferrandis, N. Muennighoff, M. Mishra, A. Gu, M. Dey, et al. Santacoder: don’t reach for the stars! arXiv preprint arXiv:2301.03988, 2023.   \n[3] J. Austin, A. Odena, M. Nye, M. Bosma, H. Michalewski, D. Dohan, E. Jiang, C. Cai, M. Terry, Q. Le, and C. Sutton. Program synthesis with large language models, 2021.   \n[4] S. Bang, S. Nam, I. Chun, H. Y. Jhoo, and J. Lee. Smt-based translation validation for machine learning compiler. In Computer Aided Verification: 34th International Conference, CAV 2022, Haifa, Israel, August 7–10, 2022, Proceedings, Part II, pages 386–407. Springer, 2022.   \n[5] S. Black, L. Gao, P. Wang, C. Leahy, and S. Biderman. GPT-Neo: Large Scale Autoregressive Language Modeling with Mesh-Tensorflow, Mar. 2021. If you use this software, please cite it using these metadata.   \n[6] T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020.   \n[7] T. A. Budd. Mutation analysis of program test data. Yale University, 1980.   \n[8] C. Cadar, D. Dunbar, D. R. Engler, et al. Klee: unassisted and automatic generation of high-coverage tests for complex systems programs. In OSDI, volume 8, pages 209–224, 2008.   \n[9] F. Cassano, J. Gouwar, D. Nguyen, S. Nguyen, L. Phipps-Costin, D. Pinckney, M.-H. Yee, Y. Zi, C. J. Anderson, M. Q. Feldman, et al. Multipl-e: A scalable and polyglot approach to benchmarking neural code generation. IEEE Transactions on Software Engineering, 2023.   \n[10] S. K. Cha, M. Woo, and D. Brumley. Program-adaptive mutational fuzzing. In 2015 IEEE Symposium on Security and Privacy, pages 725–741. IEEE, 2015.   \n[11] M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P. d. O. Pinto, J. Kaplan, H. Edwards, Y. Burda, N. Joseph, G. Brockman, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021.   \n[12] W.-L. Chiang, Z. Li, Z. Lin, Y. Sheng, Z. Wu, H. Zhang, L. Zheng, S. Zhuang, Y. Zhuang, J. E. Gonzalez, I. Stoica, and E. P. Xing. Vicuna: An open-source chatbot impressing gpt-4 with $9 0 \\% *$ chatgpt quality, March 2023.   \n[13] B. Code. Starcoder. https://github.com/bigcode-project/starcoder, 2023.   \n[14] Y. Deng, C. S. Xia, H. Peng, C. Yang, and L. Zhang. Large language models are zero-shot fuzzers: Fuzzing deep-learning libraries via large language models. In 32nd International Symposium on Software Testing and Analysis (ISSTA), 2023.   \n[15] Y. Deng, C. S. Xia, C. Yang, S. D. Zhang, S. Yang, and L. Zhang. Large language models are edge-case fuzzers: Testing deep learning libraries via fuzzgpt. In 46th International Conference on Software Engineering (ICSE), 2024.   \n[16] fauxpilot. Fauxpilot: an open-source alternative to github copilot server. https: //github.com/fauxpilot/fauxpilot, 2022.   \n[17] U. Feige. A threshold of ln n for approximating set cover. Journal of the ACM (JACM), 45(4):634–652, 1998.   \n[18] D. Fried, A. Aghajanyan, J. Lin, S. Wang, E. Wallace, F. Shi, R. Zhong, S. Yih, L. Zettlemoyer, and M. Lewis. Incoder: A generative model for code infilling and synthesis. In The Eleventh International Conference on Learning Representations, 2023.   \n[19] C. Green. Application of theorem proving to problem solving. In Readings in Artificial Intelligence, pages 202–222. Elsevier, 1981.   \n[20] S. Gulwani. Automating string processing in spreadsheets using input-output examples. SIGPLAN Not., 46(1):317–330, jan 2011.   \n[21] S. Gulwani, O. Polozov, and R. Singh. Program synthesis. Foundations and Trends® in Programming Languages, 4(1-2):1–119, 2017.   \n[22] T. Hastie, R. Tibshirani, J. H. Friedman, and J. H. Friedman. The elements of statistical learning: data mining, inference, and prediction, volume 2. Springer, 2009.   \n[23] C. Holler, K. Herzig, and A. Zeller. Fuzzing with code fragments. In 21st USENIX Security Symposium (USENIX Security 12), pages 445–458, Bellevue, WA, Aug. 2012. USENIX Association.   \n[24] M. Ivankovic, G. Petrovi ´ c, R. Just, and G. Fraser. Code coverage at google. In ´ Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 955–963, 2019.   \n[25] S. Iyer, I. Konstas, A. Cheung, and L. Zettlemoyer. Mapping language to code in programmatic context. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pages 1643–1652, 2018.   \n[26] A. Q. Jiang, A. Sablayrolles, A. Mensch, C. Bamford, D. S. Chaplot, D. d. l. Casas, F. Bressand, G. Lengyel, G. Lample, L. Saulnier, et al. Mistral 7b. arXiv preprint arXiv:2310.06825, 2023.   \n[27] N. Jiang, K. Liu, T. Lutellier, and L. Tan. Impact of code language models on automated program repair. arXiv preprint arXiv:2302.05020, 2023.   \n[28] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan. Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770, 2023.   \n[29] A. Kalyan, A. Mohta, O. Polozov, D. Batra, P. Jain, and S. Gulwani. Neural-guided deductive search for real-time program synthesis from examples. In International Conference on Learning Representations, 2018.   \n[30] J. C. King. Symbolic execution and program testing. Communications of the ACM, 19(7):385–394, 1976.   \n[31] M.-A. Lachaux, B. Roziere, L. Chanussot, and G. Lample. Unsupervised translation of programming languages. arXiv preprint arXiv:2006.03511, 2020.   \n[32] K. R. M. Leino. Dafny: An automatic program verifier for functional correctness. In International conference on logic for programming artificial intelligence and reasoning, pages 348–370. Springer, 2010.   \n[33] Y. Li, D. Choi, J. Chung, N. Kushman, J. Schrittwieser, R. Leblond, T. Eccles, J. Keeling, F. Gimeno, A. Dal Lago, et al. Competition-level code generation with alphacode. Science, 378(6624):1092–1097, 2022.   \n[34] J. Liu, Y. Wei, S. Yang, Y. Deng, and L. Zhang. Coverage-guided tensor compiler fuzzing with joint ir-pass mutation. Proceedings of the ACM on Programming Languages, 6(OOPSLA1):1–26, Apr. 2022.   \n[35] Z. Liu, C. Chen, J. Wang, X. Che, Y. Huang, J. Hu, and Q. Wang. Fill in the blank: Context-aware automated text input generation for mobile gui testing. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE), pages 1355–1367. IEEE, 2023.   \n[36] N. P. Lopes, J. Lee, C.-K. Hur, Z. Liu, and J. Regehr. Alive2: bounded translation validation for llvm. In Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation, pages 65–79, 2021.   \n[37] S. Lu, D. Guo, S. Ren, J. Huang, A. Svyatkovskiy, A. Blanco, C. Clement, D. Drain, D. Jiang, D. Tang, et al. Codexglue: A machine learning benchmark dataset for code understanding and generation. arXiv preprint arXiv:2102.04664, 2021.   \n[38] Z. Luo, C. Xu, P. Zhao, Q. Sun, X. Geng, W. Hu, C. Tao, J. Ma, Q. Lin, and D. Jiang. Wizardcoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568, 2023.   \n[39] Z. Manna and R. J. Waldinger. Toward automatic program synthesis. Communications of the ACM, 14(3):151–165, 1971.   \n[40] W. M. McKeeman. Differential testing for software. Digital Technical Journal, 10(1):100–107, 1998.   \n[41] B. Meyer. Applying’design by contract’. Computer, 25(10):40–51, 1992.   \n[42] Microsoft. GitHub Copilot – Your AI pair programmer. https://github.com/features/ copilot, 2023.   \n[43] B. P. Miller, L. Fredriksen, and B. So. An empirical study of the reliability of unix utilities. Communications of the ACM, 33(12):32–44, 1990.   \n[44] G. C. Necula. Translation validation for an optimizing compiler. In Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation, pages 83–94, 2000.   \n[45] E. Nijkamp, H. Hayashi, C. Xiong, S. Savarese, and Y. Zhou. Codegen2: Lessons for training llms on programming and natural languages. arXiv preprint, 2023.   \n[46] E. Nijkamp, B. Pang, H. Hayashi, L. Tu, H. Wang, Y. Zhou, S. Savarese, and C. Xiong. Codegen: An open large language model for code with multi-turn program synthesis. In The Eleventh International Conference on Learning Representations, 2023.   \n[47] P. Oehlert. Violating assumptions with fuzzing. IEEE Security & Privacy, 3(2):58–62, 2005.   \n[48] OpenAI. Chatgpt: Optimizing language models for dialogue. https://openai.com/blog/ chatgpt/, 2022.   \n[49] OpenAI. Gpt-4 technical report. ArXiv, abs/2303.08774, 2023.   \n[50] K. Papineni, S. Roukos, T. Ward, and W.-J. Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting of the Association for Computational Linguistics, pages 311–318, 2002.   \n[51] G. Petrovic and M. Ivankovi ´ c. State of mutation testing at google. In ´ Proceedings of the 40th international conference on software engineering: Software engineering in practice, pages 163–171, 2018.   \n[52] Phind. Phind/phind-codellama-34b-v2 $\\cdot$ hugging face. https://huggingface.co/Phind/ Phind-CodeLlama-34B-v2, 2023.   \n[53] G. Rothermel, M. J. Harrold, J. Von Ronne, and C. Hong. Empirical studies of test-suite reduction. Software Testing, Verification and Reliability, 12(4):219–249, 2002.   \n[54] B. Rozière, J. Gehring, F. Gloeckle, S. Sootla, I. Gat, X. E. Tan, Y. Adi, J. Liu, T. Remez, J. Rapin, et al. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950, 2023.   \n[55] B. Roziere, J. M. Zhang, F. Charton, M. Harman, G. Synnaeve, and G. Lample. Leveraging automated unit tests for unsupervised code translation. arXiv preprint arXiv:2110.06773, 2021.   \n[56] M. Security. jsfunfuzz. https://github.com/MozillaSecurity/funfuzz, 2007.   \n[57] K. Serebryany. Continuous fuzzing with libfuzzer and addresssanitizer. In 2016 IEEE Cybersecurity Development (SecDev), pages 157–157. IEEE, 2016.   \n[58] D. E. Shaw, W. R. Swartout, and C. C. Green. Inferring lisp programs from examples. In IJCAI, volume 75, pages 260–267, 1975.   \n[59] A. Shi, A. Gyori, M. Gligoric, A. Zaytsev, and D. Marinov. Balancing trade-offs in test-suite reduction. In Proceedings of the 22nd ACM SIGSOFT international symposium on foundations of software engineering, pages 246–256, 2014.   \n[60] Stability-AI. Stablelm: Stability ai language models. https://github.com/Stability-AI/ StableLM, 2023.   \n[61] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. Advances in neural information processing systems, 30, 2017.   \n[62] R. J. Waldinger and R. C. Lee. Prow: A step toward automatic program writing. In Proceedings of the 1st international joint conference on Artificial intelligence, pages 241–252, 1969.   \n[63] B. Wang and A. Komatsuzaki. GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model. https://github.com/kingoflolz/mesh-transformer-jax, May 2021.   \n[64] Y. Wang, H. Le, A. D. Gotmare, N. D. Bui, J. Li, and S. C. Hoi. Codet5 $^ +$ : Open code large language models for code understanding and generation. arXiv preprint arXiv:2305.07922, 2023.   \n[65] Y. Wei, C. S. Xia, and L. Zhang. Copiloting the copilots: Fusing large language models with completion engines for automated program repair. arXiv preprint arXiv:2309.00608, 2023.   \n[66] D. Winterer, C. Zhang, and Z. Su. On the unusual effectiveness of type-aware operator mutations for testing smt solvers. Proceedings of the ACM on Programming Languages, 4(OOPSLA):1–25, 2020.   \n[67] C. S. Xia, M. Paltenghi, J. L. Tian, M. Pradel, and L. Zhang. Universal fuzzing via large language models. In 46th International Conference on Software Engineering (ICSE), 2024.   \n[68] C. S. Xia, Y. Wei, and L. Zhang. Automated program repair in the era of large pre-trained language models. In Proceedings of the 45th International Conference on Software Engineering (ICSE 2023). Association for Computing Machinery, 2023.   \n[69] C. S. Xia and L. Zhang. Less training, more repairing please: revisiting automated program repair via zero-shot learning. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pages 959–971, 2022.   \n[70] F. F. Xu, U. Alon, G. Neubig, and V. J. Hellendoorn. A systematic evaluation of large language models of code. In Proceedings of the 6th ACM SIGPLAN International Symposium on Machine Programming, pages 1–10, 2022.   \n[71] C. Yang, Y. Deng, R. Lu, J. Yao, J. Liu, R. Jabbarvand, and L. Zhang. White-box compiler fuzzing empowered by large language models, 2023.   \n[72] X. Yang, Y. Chen, E. Eide, and J. Regehr. Finding and understanding bugs in c compilers. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’11, page 283–294, New York, NY, USA, 2011. Association for Computing Machinery.   \n[73] T. Yu, R. Zhang, K. Yang, M. Yasunaga, D. Wang, Z. Li, J. Ma, I. Li, Q. Yao, S. Roman, et al. Spider: A large-scale human-labeled dataset for complex and cross-domain semantic parsing and text-to-sql task. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 2018.   \n[74] M. Zalewski. American fuzzing lop (afl). https://lcamtuf.coredump.cx/afl/, 2018.   \n[75] L. Zhang, D. Marinov, L. Zhang, and S. Khurshid. An empirical study of junit test-suite reduction. In 2011 IEEE 22nd International Symposium on Software Reliability Engineering, pages 170–179. IEEE, 2011.   \n[76] Q. Zheng, X. Xia, X. Zou, Y. Dong, S. Wang, Y. Xue, Z. Wang, L. Shen, A. Wang, Y. Li, et al. Codegeex: A pre-trained model for code generation with multilingual evaluations on humaneval-x. arXiv preprint arXiv:2303.17568, 2023. ",
+        "bbox": [
+            171,
+            70,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            60,
+            828,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            73,
+            828,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            49,
+            828,
+            900
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/33e9244023fa0a208ce380903229090cd689a1a0eb15230ced8fc607433f2668.jpg",
+        "table_caption": [
+            "Table 5: Overview of evaluated models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model Name</td><td>Sizes</td><td>Release Year</td><td>Open-Source</td></tr><tr><td rowspan=\"10\">Cuipoo</td><td>2B,6B,16B</td><td>2022 2022</td><td>&lt;</td></tr><tr><td>CodeGen [46] INCODER [18]</td><td>1.3B, 6.7B</td><td>√</td></tr><tr><td>PolyCoder [70]</td><td>2.7B</td><td>2022</td></tr><tr><td>SantaCoder [2]</td><td>1.1B 2023</td><td></td></tr><tr><td>CodeGen2 [45]</td><td>1B,3B,7B,16B</td><td>2023</td></tr><tr><td>StarCoder[13]</td><td>15B 2023</td><td></td></tr><tr><td>CODET5+ [64]</td><td>16B 2023</td><td></td></tr><tr><td>CODELLAMA [54]</td><td>7B,13B,34B 2023</td><td></td></tr><tr><td>WizardCoder-CodeLlama [38]</td><td>2023</td><td></td></tr><tr><td>34B Phind-CodeLlama [52] 34B</td><td>2023</td><td></td></tr><tr><td rowspan=\"7\">GPT-J [63] Geeeeer StableLM [60]</td><td>6B</td><td>2021</td><td>√</td></tr><tr><td>GPT-NEO [5]</td><td>2.7B 2021</td><td>【</td></tr><tr><td>ChatGPT[48]</td><td>2022</td><td></td></tr><tr><td>GPT-4 [49]</td><td>N/A N/A</td><td></td></tr><tr><td>VICUNA [12]</td><td>2023 2023</td><td></td></tr><tr><td>7B,13B 7B</td><td>2023</td><td></td></tr><tr><td>MISTRAL [26]</td><td>2023</td><td></td></tr></table>",
+        "bbox": [
+            202,
+            106,
+            795,
+            378
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A Detailed Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            401,
+            447,
+            420
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Evaluation of LLMs. Our goal is to comprehensively evaluate recent and widely used LLMs, both specialized for code generation [46, 70, 18, 2, 52, 38, 64] and general-purpose tasks [49, 48, 12, 60, 63, 5, 26]. Table 5 presents an overview of the studied models, with column Sizes reflecting the model sizes in billions of parameters, Release Year showing when the LLM is released, and Open-Source marking the models whose weights are publicly available. In total, we evaluate 26 of the most representative and popular LLMs with a broad range of configurations to fully demonstrate the generalizability of our results. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            534
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Our hyper-parameter configurations follow prior work [11, 46]. For each model we randomly sample 200 programs and repeat the experiments over temperature $( \\{ 0 . 2 , 0 . 4 , 0 . 6 , 0 . 8 \\} )$ and greedy decoding with zero temperature. By default, we let each model generate at most 512 new tokens and truncate the produced code with end-of-string (EOS) identifiers suggested in HUMANEVAL [11], as well as those favoured by certain models (e.g., “<|endoftext $| > ^ { \\dag }$ and $\\cdots ( n ^ { - , - , 3 } )$ . For conversational models (i.e., ChatGPT and GPT-4), we obtain the code fragments by parsing the code blocks (i.e., within “\\`\\`\\`”) in the output. We found ChatGPT tends to repeat problem description with detailed explanation, which can consume more than 512 new tokens to complete a solution for around $11 \\%$ of problems. To align ChatGPT with other models, for tasks with very long problem descriptions, we extend the token limit from 512 to 1024. For model implementation, we run ChatGPT and GPT-4 via OpenAI APIs, and accelerate CodeGen-6B and -16B with NVIDIA FasterTransformer via FauxPilot [16]. All other LLMs are based on the HuggingFace transformers library. By default, we follow the official examples of each LLM (e.g., on HuggingFace model card) to construct their corresponding prompts. Specifically, the prompts used for ChatGPT, GPT-4, and WizardCoder-CodeLlama is instruction-based, i.e., a simple instruction is used to wrap the function signature and docstring to explicitly encourage the LLM for code generation. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            761
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Test oracles. An LLM-produced solution is regarded to be correct if for all test inputs it returns values that match the expected outputs within a reasonable run time. We perform exact matching by default. For floating-point comparisons, we tolerate absolute differences to the degrees annotated in HUMANEVAL or $1 \\bar { 0 } ^ { - 6 }$ if not annotated. In original HUMANEVAL, the default timeout is set to three seconds to run the whole test-suite (i.e., all test-cases) for each programming problem. Such a setting is neither suitable when having more test-cases nor reasonable as each problem could have its own run time characteristics. Consequently, we let the timeout for each test-case to be $\\mathrm { m a x } ( 2 0 0 \\mathrm { m s } , 4 \\times t _ { g t } )$ where $t _ { g t }$ refers to the execution time of the corresponding ground-truth solution. In other words, we expect the LLM-provided solution to be no slower than the ground-truth by four times or use a base 200-millisecond timeout when $4 \\times t _ { g t } < 2 0 0 \\mathrm { m s }$ to avoid variance caused by performance randomness. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            909
+        ],
+        "page_idx": 14
+    }
+]

parse/dev/1qvx610Cu7/1qvx610Cu7_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/dev/1qvx610Cu7/1qvx610Cu7_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/dev/2-REuflJDT/2-REuflJDT_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:ec580c3956eaa28b09ceca108e96b2c0b07b0c9dabaeb43c37ce5a393d8314be
+size 1159575

parse/dev/2-REuflJDT/2-REuflJDT_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:8ed8b1fe6f3c9913f40f40cb87b1be3cc4dfd27c699938a0c28533f4b22c5c03
+size 1022913

parse/dev/2-REuflJDT/2-REuflJDT_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:bb175495e78ddc1764bb9dc84c4e7892c52da1459d92e353674be51bc2fdb7e1
+size 1172273

parse/dev/2EufPS5ABlJ/2EufPS5ABlJ_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:877bce2272a77189738027bf8f76b3ee0cdc4113f4e927cec124890ebe31694b
+size 3286797

parse/dev/2EufPS5ABlJ/2EufPS5ABlJ_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:21a354d7ca72c149e860f460e6d30ea4061766b33154c38899c8070fd9c9359a
+size 2699136

parse/dev/2EufPS5ABlJ/2EufPS5ABlJ_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:6f61a8c2001269e7c1b9f0b005cc73dd1f47669b8a9cafdcb4654158b76a97b8
+size 3336756

parse/dev/2hMEdc35xZ6/2hMEdc35xZ6_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:2792621e9432031ec2543d56be8fc88c94027bd94c004801ad192ac00206e376
+size 16364274

parse/dev/2hMEdc35xZ6/2hMEdc35xZ6_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:3880c402fe6a8740f7cb165b70ae418cd6b999037e3d62d5a0dd2063c3aa8fef
+size 16051119

parse/dev/2hMEdc35xZ6/2hMEdc35xZ6_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:bba596b493823dfa595a8ec89a7019d3a624f0fc2dd6eb57c2987d53dcd7b03b
+size 16366332

parse/dev/2nJdh_C-UWe/2nJdh_C-UWe_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:ef3dcc8b0967c133e6335191b8bfc1dec3ba88f6d99b2c2b111800e6fd1ca3d9
+size 5466456

parse/dev/3FvF1db-bKT/3FvF1db-bKT_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:47b5c482330a8ca7224f2ea03ecd829855cdf380e1fd6eb9d88e64447cf29596
+size 535862

parse/dev/3s9IrEsjLyk/3s9IrEsjLyk_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:ce71fa89016ba8580cf8d87840c7c21c1791a0e3d4217721a1380ee296917244
+size 3632092

parse/dev/3s9IrEsjLyk/3s9IrEsjLyk_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:07c1a83c66df5e6f853243674479b9df22455c034102108099f049aaffe8caac
+size 1212267

parse/dev/3s9IrEsjLyk/3s9IrEsjLyk_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:0831f7b87fc94e1129df3fa05294c324505958e09b2017d622b9163d00386fd5
+size 3642564

parse/dev/3tYvDb4dwab/3tYvDb4dwab_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:6d7ad0b94132b84718cc64675f032a4aeb46ee2c1e5403b2f9e996ea55b9a182
+size 7486022

parse/dev/3tYvDb4dwab/3tYvDb4dwab_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:2d20f7237486e5e0950a146015753afc0064affa79371f7b1f4639fd5fc15bfc
+size 7341687

parse/dev/3tYvDb4dwab/3tYvDb4dwab_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:95840ba443256bb959d5b581165136bd5fbb4b21beed0dea2d9cf4f1bc28cc82
+size 7485158

parse/dev/401LFvBGIb/401LFvBGIb_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:c120d66475936c383b909f8f3e18074a42a23edc311138fc3cb4414be29996ca
+size 452982

parse/dev/5JdLZg346Lw/5JdLZg346Lw_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:5447b1de4b27659672ab4f1b57f511e60275cd0ac8bf3e079829a48aebfac56b
+size 20739815

parse/dev/5JdLZg346Lw/5JdLZg346Lw_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:d635549e4d6a87554699290f612470fe81439485023c1b0cb6724b60f2afc172
+size 20381215

parse/dev/5JdLZg346Lw/5JdLZg346Lw_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:378faee542feb44360756d36e47a9459f45e1b2a7e98b196d5a4ffb6a942e04f
+size 20747931

parse/dev/68n2s9ZJWF8/68n2s9ZJWF8_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:18e9eac84c2678ec1be3ff44d29b01af2a93d167bd5c43c263c47f194ab5e3cb
+size 1176781

parse/dev/68n2s9ZJWF8/68n2s9ZJWF8_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:7fabffff353427bbe668c76db834e93b00c9e45b739e86f428d4df38114cd4bb
+size 932013

parse/dev/68n2s9ZJWF8/68n2s9ZJWF8_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:33ecd34ee3b72cca2a9a55a7b3a7342287e9c2ec71ae9f8b8f4cd8551a904812
+size 1185759

parse/dev/6HN7LHyzGgC/6HN7LHyzGgC_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:6b94c011554d0b0148ced7a2f07274eb03b4dd3aa26ee4df86c0633e4410d55d
+size 4892933

parse/dev/6HN7LHyzGgC/6HN7LHyzGgC_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:1ed4d96e974ecafd4fb5e8d311f0311dc69c8f59c801d96137edf1bbe64e72c5
+size 4734433

parse/dev/6HN7LHyzGgC/6HN7LHyzGgC_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:17171b0622e5087d5a6f73cea9da86fbc843478fa91fedfacdd82a26954cc03b
+size 4890362

parse/dev/6dlC7E1H_9/6dlC7E1H_9_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:dcb3357f2beb8c8f4172d5ed690d29c0dd488516e2216d6d68a02d347a42d8dd
+size 2714472

parse/dev/6dlC7E1H_9/6dlC7E1H_9_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:754b6f8f8613bdca084ce33a89fa908f81bbf343c29828f8bd59d478c13acbf9
+size 2407825

parse/dev/6dlC7E1H_9/6dlC7E1H_9_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:85d44a895de47a2ceeaaff23d5b84ef28d439165c18dd1a7ac43949f32150d13
+size 2791446

parse/dev/89ia77nZ8u/89ia77nZ8u_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:83956bead603edd57268723ab7cbc4348f77e75d51c2b7f97f3975af9ac36549
+size 5400323

parse/dev/89ia77nZ8u/89ia77nZ8u_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:0454a6334ad35bae58208972e42d798b40e05afbc4d7e0a2052a1a090d713a91
+size 5083219

parse/dev/89ia77nZ8u/89ia77nZ8u_span.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:5f6ec1466adfbfa51741a865d6ddeb5c1cc767ecd62e5e07a637cdb9d4ef56de
+size 5407427

parse/dev/8aHzds2uUyB/8aHzds2uUyB_layout.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:f9154c2b4a3a3206066d006050140257d870c284497f7cafdd3ec286fd65e99a
+size 3096602

parse/dev/8aHzds2uUyB/8aHzds2uUyB_origin.pdf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:8a04f5165fec78c8b27ab89bba401350a59d66fca383baea31961e1bcb9d14af
+size 2342518