libavcodec/mpegvideo.c:694: error: Null Dereference
  pointer `s->mb_index2xy` last assigned on line 688 could be null and is dereferenced at line 694, column 5.

libavcodec/mpegvideo.c:659:1: start of procedure init_context_frame()
657.  * Initialize and allocates MpegEncContext fields dependent on the resolution.
658.  */
659. static int init_context_frame(MpegEncContext *s)
     ^
660. {
661.     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;

libavcodec/mpegvideo.c:663:5: 
661.     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
662. 
663.     s->mb_width   = (s->width + 15) / 16;
         ^
664.     s->mb_stride  = s->mb_width + 1;
665.     s->b8_stride  = s->mb_width * 2 + 1;

libavcodec/mpegvideo.c:664:5: 
662. 
663.     s->mb_width   = (s->width + 15) / 16;
664.     s->mb_stride  = s->mb_width + 1;
         ^
665.     s->b8_stride  = s->mb_width * 2 + 1;
666.     s->b4_stride  = s->mb_width * 4 + 1;

libavcodec/mpegvideo.c:665:5: 
663.     s->mb_width   = (s->width + 15) / 16;
664.     s->mb_stride  = s->mb_width + 1;
665.     s->b8_stride  = s->mb_width * 2 + 1;
         ^
666.     s->b4_stride  = s->mb_width * 4 + 1;
667.     mb_array_size = s->mb_height * s->mb_stride;

libavcodec/mpegvideo.c:666:5: 
664.     s->mb_stride  = s->mb_width + 1;
665.     s->b8_stride  = s->mb_width * 2 + 1;
666.     s->b4_stride  = s->mb_width * 4 + 1;
         ^
667.     mb_array_size = s->mb_height * s->mb_stride;
668.     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;

libavcodec/mpegvideo.c:667:5: 
665.     s->b8_stride  = s->mb_width * 2 + 1;
666.     s->b4_stride  = s->mb_width * 4 + 1;
667.     mb_array_size = s->mb_height * s->mb_stride;
         ^
668.     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
669. 

libavcodec/mpegvideo.c:668:5: 
666.     s->b4_stride  = s->mb_width * 4 + 1;
667.     mb_array_size = s->mb_height * s->mb_stride;
668.     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
         ^
669. 
670.     /* set default edge pos, will be overriden

libavcodec/mpegvideo.c:672:5: 
670.     /* set default edge pos, will be overriden
671.      * in decode_header if needed */
672.     s->h_edge_pos = s->mb_width * 16;
         ^
673.     s->v_edge_pos = s->mb_height * 16;
674. 

libavcodec/mpegvideo.c:673:5: 
671.      * in decode_header if needed */
672.     s->h_edge_pos = s->mb_width * 16;
673.     s->v_edge_pos = s->mb_height * 16;
         ^
674. 
675.     s->mb_num     = s->mb_width * s->mb_height;

libavcodec/mpegvideo.c:675:5: 
673.     s->v_edge_pos = s->mb_height * 16;
674. 
675.     s->mb_num     = s->mb_width * s->mb_height;
         ^
676. 
677.     s->block_wrap[0] =

libavcodec/mpegvideo.c:677:5: 
675.     s->mb_num     = s->mb_width * s->mb_height;
676. 
677.     s->block_wrap[0] =
         ^
678.     s->block_wrap[1] =
679.     s->block_wrap[2] =

libavcodec/mpegvideo.c:681:5: 
679.     s->block_wrap[2] =
680.     s->block_wrap[3] = s->b8_stride;
681.     s->block_wrap[4] =
         ^
682.     s->block_wrap[5] = s->mb_stride;
683. 

libavcodec/mpegvideo.c:684:5: 
682.     s->block_wrap[5] = s->mb_stride;
683. 
684.     y_size  = s->b8_stride * (2 * s->mb_height + 1);
         ^
685.     c_size  = s->mb_stride * (s->mb_height + 1);
686.     yc_size = y_size + 2   * c_size;

libavcodec/mpegvideo.c:685:5: 
683. 
684.     y_size  = s->b8_stride * (2 * s->mb_height + 1);
685.     c_size  = s->mb_stride * (s->mb_height + 1);
         ^
686.     yc_size = y_size + 2   * c_size;
687. 

libavcodec/mpegvideo.c:686:5: 
684.     y_size  = s->b8_stride * (2 * s->mb_height + 1);
685.     c_size  = s->mb_stride * (s->mb_height + 1);
686.     yc_size = y_size + 2   * c_size;
         ^
687. 
688.     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),

libavcodec/mpegvideo.c:688:5: 
686.     yc_size = y_size + 2   * c_size;
687. 
688.     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
         ^
689.                       fail); // error ressilience code looks cleaner with this
690.     for (y = 0; y < s->mb_height; y++)

libavutil/mem.c:160:1: start of procedure av_mallocz()
  158. }
  159. 
  160. void *av_mallocz(size_t size)
       ^
  161. {
  162.     void *ptr = av_malloc(size);

libavutil/mem.c:162:5: 
  160. void *av_mallocz(size_t size)
  161. {
  162.     void *ptr = av_malloc(size);
           ^
  163.     if (ptr)
  164.         memset(ptr, 0, size);

libavutil/mem.c:64:1: start of procedure av_malloc()
    62.    linker will do it automatically. */
    63. 
    64. void *av_malloc(size_t size)
        ^
    65. {
    66.     void *ptr = NULL;

libavutil/mem.c:66:5: 
    64. void *av_malloc(size_t size)
    65. {
    66.     void *ptr = NULL;
            ^
    67. #if CONFIG_MEMALIGN_HACK
    68.     long diff;

libavutil/mem.c:72:9: Taking true branch
    70. 
    71.     /* let's disallow possible ambiguous cases */
    72.     if (size > (INT_MAX-32) || !size)
                ^
    73.         return NULL;
    74. 

libavutil/mem.c:73:9: 
    71.     /* let's disallow possible ambiguous cases */
    72.     if (size > (INT_MAX-32) || !size)
    73.         return NULL;
                ^
    74. 
    75. #if CONFIG_MEMALIGN_HACK

libavutil/mem.c:117:1: return from a call to av_malloc
    115. #endif
    116.     return ptr;
    117. }
         ^
    118. 
    119. void *av_realloc(void *ptr, size_t size)

libavutil/mem.c:163:9: Taking false branch
  161. {
  162.     void *ptr = av_malloc(size);
  163.     if (ptr)
               ^
  164.         memset(ptr, 0, size);
  165.     return ptr;

libavutil/mem.c:165:5: 
  163.     if (ptr)
  164.         memset(ptr, 0, size);
  165.     return ptr;
           ^
  166. }
  167. 

libavutil/mem.c:166:1: return from a call to av_mallocz
  164.         memset(ptr, 0, size);
  165.     return ptr;
  166. }
       ^
  167. 
  168. char *av_strdup(const char *s)

libavcodec/mpegvideo.c:688:5: Taking true branch
686.     yc_size = y_size + 2   * c_size;
687. 
688.     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
         ^
689.                       fail); // error ressilience code looks cleaner with this
690.     for (y = 0; y < s->mb_height; y++)

libavcodec/mpegvideo.c:688:5: Taking false branch
686.     yc_size = y_size + 2   * c_size;
687. 
688.     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
         ^
689.                       fail); // error ressilience code looks cleaner with this
690.     for (y = 0; y < s->mb_height; y++)

libavcodec/mpegvideo.c:690:10: 
688.     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
689.                       fail); // error ressilience code looks cleaner with this
690.     for (y = 0; y < s->mb_height; y++)
              ^
691.         for (x = 0; x < s->mb_width; x++)
692.             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;

libavcodec/mpegvideo.c:690:17: Loop condition is false. Leaving loop
688.     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
689.                       fail); // error ressilience code looks cleaner with this
690.     for (y = 0; y < s->mb_height; y++)
                     ^
691.         for (x = 0; x < s->mb_width; x++)
692.             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;

libavcodec/mpegvideo.c:694:5: 
692.             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
693. 
694.     s->mb_index2xy[s->mb_height * s->mb_width] =
         ^
695.         (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
696. 

static int init_context_frame(MpegEncContext *s)
{
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
    s->mb_width   = (s->width + 15) / 16;
    s->mb_stride  = s->mb_width + 1;
    s->b8_stride  = s->mb_width * 2 + 1;
    s->b4_stride  = s->mb_width * 4 + 1;
    mb_array_size = s->mb_height * s->mb_stride;
    mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
    s->h_edge_pos = s->mb_width * 16;
    s->v_edge_pos = s->mb_height * 16;
    s->mb_num     = s->mb_width * s->mb_height;
    s->block_wrap[0] =
    s->block_wrap[1] =
    s->block_wrap[2] =
    s->block_wrap[3] = s->b8_stride;
    s->block_wrap[4] =
    s->block_wrap[5] = s->mb_stride;
    y_size  = s->b8_stride * (2 * s->mb_height + 1);
    c_size  = s->mb_stride * (s->mb_height + 1);
    yc_size = y_size + 2   * c_size;
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
                      fail);
    for (y = 0; y < s->mb_height; y++)
        for (x = 0; x < s->mb_width; x++)
            s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
    s->mb_index2xy[s->mb_height * s->mb_width] =
        (s->mb_height - 1) * s->mb_stride + s->mb_width;
    if (s->encoding) {
        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
                          mv_table_size * 2 * sizeof(int16_t), fail);
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
                          mv_table_size * 2 * sizeof(int16_t), fail);
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
                          mv_table_size * 2 * sizeof(int16_t), fail);
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
                          mv_table_size * 2 * sizeof(int16_t), fail);
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
                          mv_table_size * 2 * sizeof(int16_t), fail);
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
                          mv_table_size * 2 * sizeof(int16_t), fail);
        s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
        s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
        s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
        s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
                                   s->mb_stride + 1;
        s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
                                   s->mb_stride + 1;
        s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
                          sizeof(uint16_t), fail);
        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
                          sizeof(int), fail);
        FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
                         mb_array_size * sizeof(float), fail);
        FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
                         mb_array_size * sizeof(float), fail);
    }
    FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
                     mb_array_size * sizeof(uint8_t), fail);
    FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
                      mb_array_size * sizeof(uint8_t), fail);
    if (s->codec_id == AV_CODEC_ID_MPEG4 ||
        (s->flags & CODEC_FLAG_INTERLACED_ME)) {
        for (i = 0; i < 2; i++) {
            int j, k;
            for (j = 0; j < 2; j++) {
                for (k = 0; k < 2; k++) {
                    FF_ALLOCZ_OR_GOTO(s->avctx,
                                      s->b_field_mv_table_base[i][j][k],
                                      mv_table_size * 2 * sizeof(int16_t),
                                      fail);
                    s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
                                                   s->mb_stride + 1;
                }
                FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
                                  mb_array_size * 2 * sizeof(uint8_t), fail);
                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
                                  mv_table_size * 2 * sizeof(int16_t), fail);
                s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
                                            + s->mb_stride + 1;
            }
            FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
                              mb_array_size * 2 * sizeof(uint8_t), fail);
        }
    }
    if (s->out_format == FMT_H263) {
        FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
        s->coded_block = s->coded_block_base + s->b8_stride + 1;
        FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
                          mb_array_size * sizeof(uint8_t), fail);
        FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
                          mb_array_size * sizeof(uint8_t), fail);
    }
    if (s->h263_pred || s->h263_plus || !s->encoding) {
        FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
                          yc_size * sizeof(int16_t), fail);
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
        s->dc_val[2] = s->dc_val[1] + c_size;
        for (i = 0; i < yc_size; i++)
            s->dc_val_base[i] = 1024;
    }
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
    memset(s->mbintra_table, 1, mb_array_size);
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
    if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
        s->avctx->debug_mv) {
        s->visualization_buffer[0] = av_malloc((s->mb_width * 16 +
                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
        s->visualization_buffer[1] = av_malloc((s->mb_width * 16 +
                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
        s->visualization_buffer[2] = av_malloc((s->mb_width * 16 +
                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
    }
    return 0;
fail:
    return AVERROR(ENOMEM);
}
['static int init_context_frame(MpegEncContext *s)\n{\n    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;\n    s->mb_width   = (s->width + 15) / 16;\n    s->mb_stride  = s->mb_width + 1;\n    s->b8_stride  = s->mb_width * 2 + 1;\n    s->b4_stride  = s->mb_width * 4 + 1;\n    mb_array_size = s->mb_height * s->mb_stride;\n    mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;\n    s->h_edge_pos = s->mb_width * 16;\n    s->v_edge_pos = s->mb_height * 16;\n    s->mb_num     = s->mb_width * s->mb_height;\n    s->block_wrap[0] =\n    s->block_wrap[1] =\n    s->block_wrap[2] =\n    s->block_wrap[3] = s->b8_stride;\n    s->block_wrap[4] =\n    s->block_wrap[5] = s->mb_stride;\n    y_size  = s->b8_stride * (2 * s->mb_height + 1);\n    c_size  = s->mb_stride * (s->mb_height + 1);\n    yc_size = y_size + 2   * c_size;\n    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),\n                      fail);\n    for (y = 0; y < s->mb_height; y++)\n        for (x = 0; x < s->mb_width; x++)\n            s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;\n    s->mb_index2xy[s->mb_height * s->mb_width] =\n        (s->mb_height - 1) * s->mb_stride + s->mb_width;\n    if (s->encoding) {\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,\n                          mv_table_size * 2 * sizeof(int16_t), fail);\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,\n                          mv_table_size * 2 * sizeof(int16_t), fail);\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,\n                          mv_table_size * 2 * sizeof(int16_t), fail);\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,\n                          mv_table_size * 2 * sizeof(int16_t), fail);\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,\n                          mv_table_size * 2 * sizeof(int16_t), fail);\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,\n                          mv_table_size * 2 * sizeof(int16_t), fail);\n        s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;\n        s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;\n        s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;\n        s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +\n                                   s->mb_stride + 1;\n        s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +\n                                   s->mb_stride + 1;\n        s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *\n                          sizeof(uint16_t), fail);\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *\n                          sizeof(int), fail);\n        FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,\n                         mb_array_size * sizeof(float), fail);\n        FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,\n                         mb_array_size * sizeof(float), fail);\n    }\n    FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,\n                     mb_array_size * sizeof(uint8_t), fail);\n    FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,\n                      mb_array_size * sizeof(uint8_t), fail);\n    if (s->codec_id == AV_CODEC_ID_MPEG4 ||\n        (s->flags & CODEC_FLAG_INTERLACED_ME)) {\n        for (i = 0; i < 2; i++) {\n            int j, k;\n            for (j = 0; j < 2; j++) {\n                for (k = 0; k < 2; k++) {\n                    FF_ALLOCZ_OR_GOTO(s->avctx,\n                                      s->b_field_mv_table_base[i][j][k],\n                                      mv_table_size * 2 * sizeof(int16_t),\n                                      fail);\n                    s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +\n                                                   s->mb_stride + 1;\n                }\n                FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],\n                                  mb_array_size * 2 * sizeof(uint8_t), fail);\n                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],\n                                  mv_table_size * 2 * sizeof(int16_t), fail);\n                s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]\n                                            + s->mb_stride + 1;\n            }\n            FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],\n                              mb_array_size * 2 * sizeof(uint8_t), fail);\n        }\n    }\n    if (s->out_format == FMT_H263) {\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);\n        s->coded_block = s->coded_block_base + s->b8_stride + 1;\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,\n                          mb_array_size * sizeof(uint8_t), fail);\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,\n                          mb_array_size * sizeof(uint8_t), fail);\n    }\n    if (s->h263_pred || s->h263_plus || !s->encoding) {\n        FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,\n                          yc_size * sizeof(int16_t), fail);\n        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;\n        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;\n        s->dc_val[2] = s->dc_val[1] + c_size;\n        for (i = 0; i < yc_size; i++)\n            s->dc_val_base[i] = 1024;\n    }\n    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);\n    memset(s->mbintra_table, 1, mb_array_size);\n    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);\n    if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||\n        s->avctx->debug_mv) {\n        s->visualization_buffer[0] = av_malloc((s->mb_width * 16 +\n                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);\n        s->visualization_buffer[1] = av_malloc((s->mb_width * 16 +\n                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);\n        s->visualization_buffer[2] = av_malloc((s->mb_width * 16 +\n                    2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);\n    }\n    return 0;\nfail:\n    return AVERROR(ENOMEM);\n}', 'void *av_mallocz(size_t size)\n{\n    void *ptr = av_malloc(size);\n    if (ptr)\n        memset(ptr, 0, size);\n    return ptr;\n}', 'void *av_malloc(size_t size)\n{\n    void *ptr = NULL;\n#if CONFIG_MEMALIGN_HACK\n    long diff;\n#endif\n    if (size > (INT_MAX-32) || !size)\n        return NULL;\n#if CONFIG_MEMALIGN_HACK\n    ptr = malloc(size+32);\n    if(!ptr)\n        return ptr;\n    diff= ((-(long)ptr - 1)&31) + 1;\n    ptr = (char*)ptr + diff;\n    ((char*)ptr)[-1]= diff;\n#elif HAVE_POSIX_MEMALIGN\n    if (posix_memalign(&ptr,32,size))\n        ptr = NULL;\n#elif HAVE_ALIGNED_MALLOC\n    ptr = _aligned_malloc(size, 32);\n#elif HAVE_MEMALIGN\n    ptr = memalign(32,size);\n#else\n    ptr = malloc(size);\n#endif\n    return ptr;\n}']