submit_packet(PerThreadContext * p, AVCodecContext * user_avctx, AVPacket * avpkt){
    pthread_mutex_lock(&p->mutex);
    
    // wait for previous thread setting done
    if (prev_thread) {
            while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
                pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
    }
    
    // upload data and sync
    av_packet_unref(p->avpkt);
    ret = av_packet_ref(p->avpkt, avpkt);
    // this will block next thread, until relevant decoding-thread unlock this by calling ff_thread_finish_setup
    atomic_store(&p->state, STATE_SETTING_UP);
    pthread_cond_signal(&p->input_cond);
    pthread_mutex_unlock(&p->mutex);
    
    
    fctx->prev_thread = p;
    fctx->next_decoding++;
}

static attribute_align_arg void *frame_worker_thread(void *arg){
    thread_set_name(p);
    
    while (1) {
        while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)
            pthread_cond_wait(&p->input_cond, &p->mutex);
    
        if (!codec->update_thread_context)
            ff_thread_finish_setup(avctx);
        
        av_frame_unref(p->frame);
        p->got_frame = 0;
        p->result = codec->cb.decode(avctx, p->frame, &p->got_frame, p->avpkt);
        
        // in case of cb.decode does not take care of state changing
        if (atomic_load(&p->state) == STATE_SETTING_UP)
            ff_thread_finish_setup(avctx);
        
        atomic_store(&p->state, STATE_INPUT_READY);
    }
}

static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS))
        h->current_slice = 0;
    
    ff_h2645_packet_split();
    
    for (i = 0; i < h->pkt.nb_nals; i++){
        switch (nal->type) {
        case H264_NAL_SLICE: 
                ff_h264_queue_decode_slice(){
                    h264_slice_header_parse(h, sl, nal);
                    h264_slice_init(){
    					sl->slice_num = ++h->current_slice;
                    }
                }
                ff_thread_finish_setup(avctx);
                // see, decoding after passing signal of SETUP_FINISHED
                ff_h264_execute_decode_slices(h);
    }
}

for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl, ImportState); !AtEOF;
     AtEOF = P.ParseTopLevelDecl(ADecl, ImportState)) {
  // If we got a null return and something *was* parsed, ignore it.  This
  // is due to a top-level semicolon, an action override, or a parse error
  // skipping something.
  if (ADecl && !Consumer->HandleTopLevelDecl(ADecl.get())) // CodeGen
    return;
}

// printf(    $tok place$ "xxx")
>    clang::Parser::ParseExpressionList(llvm::SmallVectorImpl & Exprs, llvm::function_ref ExpressionStarts, bool FailImmediatelyOnInvalidExpr, bool EarlyTypoCorrection)
     clang::Parser::ParsePostfixExpressionSuffix(clang::ActionResult LHS)
     clang::Parser::ParseCastExpression(clang::Parser::CastParseKind ParseKind, bool isAddressOfOperand, bool & NotCastExpr, clang::Parser::TypeCastState isTypeCast, bool isVectorLiteral, bool * NotPrimaryExpression)
     clang::Parser::ParseCastExpression(clang::Parser::CastParseKind ParseKind, bool isAddressOfOperand, clang::Parser::TypeCastState isTypeCast, bool isVectorLiteral, bool * NotPrimaryExpression)
     clang::Parser::ParseAssignmentExpression(clang::Parser::TypeCastState isTypeCast)
     clang::Parser::ParseExpression(clang::Parser::TypeCastState isTypeCast)
     clang::Parser::ParseExprStatement(clang::Parser::ParsedStmtContext StmtCtx)
     clang::Parser::ParseStatementOrDeclarationAfterAttributes(llvm::SmallVector & Stmts, clang::Parser::ParsedStmtContext StmtCtx, clang::SourceLocation * TrailingElseLoc, clang::ParsedAttributes & CXX11Attrs, clang::ParsedAttributes & GNUAttrs)
     clang::Parser::ParseStatementOrDeclaration(llvm::SmallVector & Stmts, clang::Parser::ParsedStmtContext StmtCtx, clang::SourceLocation * TrailingElseLoc)
     clang::Parser::ParseCompoundStatementBody(bool isStmtExpr)
     clang::Parser::ParseFunctionStatementBody(clang::Decl * Decl, clang::Parser::ParseScope & BodyScope)
     clang::Parser::ParseFunctionDefinition(clang::ParsingDeclarator & D, const clang::Parser::ParsedTemplateInfo & TemplateInfo, clang::Parser::LateParsedAttrList * LateParsedAttrs)
     clang::Parser::ParseDeclGroup(clang::ParsingDeclSpec & DS, clang::DeclaratorContext Context, clang::ParsedAttributes & Attrs, clang::SourceLocation * DeclEnd, clang::Parser::ForRangeInit * FRI)
     clang::Parser::ParseDeclOrFunctionDefInternal(clang::ParsedAttributes & Attrs, clang::ParsedAttributes & DeclSpecAttrs, clang::ParsingDeclSpec & DS, clang::AccessSpecifier AS)
     clang::Parser::ParseDeclarationOrFunctionDefinition(clang::ParsedAttributes & Attrs, clang::ParsedAttributes & DeclSpecAttrs, clang::ParsingDeclSpec * DS, clang::AccessSpecifier AS)
     clang::Parser::ParseExternalDeclaration(clang::ParsedAttributes & Attrs, clang::ParsedAttributes & DeclSpecAttrs, clang::ParsingDeclSpec * DS)
     clang::Parser::ParseTopLevelDecl(clang::OpaquePtr & Result, clang::Sema::ModuleImportState & ImportState)
     clang::ParseAST(clang::Sema & S, bool PrintStats, bool SkipFunctionBodies)
     clang::ASTFrontendAction::ExecuteAction()
     clang::CodeGenAction::ExecuteAction()
     clang::FrontendAction::Execute()
     clang::CompilerInstance::ExecuteAction(clang::FrontendAction & Act)

clang::OverloadCandidateSet::BestViableFunction(clang::Sema & S, clang::SourceLocation Loc, clang::OverloadCandidate * & Best)
 clang::Sema::BuildOverloadedCallExpr(clang::Scope * S, clang::Expr * Fn, clang::UnresolvedLookupExpr * ULE, clang::SourceLocation LParenLoc, llvm::MutableArrayRef Args, clang::SourceLocation RParenLoc, clang::Expr * ExecConfig, bool AllowTypoCorrection, bool CalleesAddressIsTaken)
 clang::Sema::BuildCallExpr(clang::Scope * Scope, clang::Expr * Fn, clang::SourceLocation LParenLoc, llvm::MutableArrayRef ArgExprs, clang::SourceLocation RParenLoc, clang::Expr * ExecConfig, bool IsExecConfig, bool AllowRecovery)
 clang::Sema::ActOnCallExpr(clang::Scope * Scope, clang::Expr * Fn, clang::SourceLocation LParenLoc, llvm::MutableArrayRef ArgExprs, clang::SourceLocation RParenLoc, clang::Expr * ExecConfig)

TextDiagnostic::emitDiagnosticMessage(clang::FullSourceLoc Loc, clang::PresumedLoc PLoc, clang::DiagnosticsEngine::Level Level, llvm::StringRef Message, llvm::ArrayRef<clang::CharSourceRange> Ranges, llvm::PointerUnion<clang::Diagnostic const *,clang::StoredDiagnostic const *> D)
DiagnosticRenderer::emitDiagnostic(clang::FullSourceLoc Loc, clang::DiagnosticsEngine::Level Level, llvm::StringRef Message, llvm::ArrayRef<clang::CharSourceRange> Ranges, llvm::ArrayRef<clang::FixItHint> FixItHints, llvm::PointerUnion<clang::Diagnostic const *,clang::StoredDiagnostic const *> D) 
TextDiagnosticPrinter::HandleDiagnostic(clang::DiagnosticsEngine::Level Level, const clang::Diagnostic & Info) 
DiagnosticIDs::EmitDiag(clang::DiagnosticsEngine & Diag, clang::DiagnosticIDs::Level DiagLevel) 
DiagnosticIDs::ProcessDiag(clang::DiagnosticsEngine & Diag) 
DiagnosticsEngine::ProcessDiag() 
DiagnosticsEngine::EmitCurrentDiagnostic(bool Force) 
DiagnosticBuilder::Emit() 
DiagnosticBuilder::~DiagnosticBuilder() 
Parser::ParseCastExpression(clang::Parser::CastParseKind ParseKind, bool isAddressOfOperand, clang::Parser::TypeCastState isTypeCast, bool isVectorLiteral, bool * NotPrimaryExpression) 
Parser::ParseRHSOfBinaryExpression(clang::ActionResult<clang::Expr *,1> LHS, clang::prec::Level MinPrec) 
Parser::ParseAssignmentExpression(clang::Parser::TypeCastState isTypeCast) 
Parser::ParseExpression(clang::Parser::TypeCastState isTypeCast) 
Parser::ParseExprStatement(clang::Parser::ParsedStmtContext StmtCtx) 
Parser::ParseStatementOrDeclarationAfterAttributes(llvm::SmallVector<clang::Stmt *,32> & Stmts, clang::Parser::ParsedStmtContext StmtCtx, clang::SourceLocation * TrailingElseLoc, clang::ParsedAttributes & CXX11Attrs, clang::ParsedAttributes & GNUAttrs) 
Parser::ParseStatementOrDeclaration(llvm::SmallVector<clang::Stmt *,32> & Stmts, clang::Parser::ParsedStmtContext StmtCtx, clang::SourceLocation * TrailingElseLoc) 
Parser::ParseCompoundStatementBody(bool isStmtExpr) 
Parser::ParseFunctionStatementBody(clang::Decl * Decl, clang::Parser::ParseScope & BodyScope) 
Parser::ParseFunctionDefinition(clang::ParsingDeclarator & D, const clang::Parser::ParsedTemplateInfo & TemplateInfo, clang::Parser::LateParsedAttrList * LateParsedAttrs) 
Parser::ParseDeclGroup(clang::ParsingDeclSpec & DS, clang::DeclaratorContext Context, clang::ParsedAttributes & Attrs, clang::SourceLocation * DeclEnd, clang::Parser::ForRangeInit * FRI) 

clang::CodeGen::CodeGenFunction::GenerateCode(clang::GlobalDecl GD, llvm::Function * Fn, const clang::CodeGen::CGFunctionInfo & FnInfo)
{
    ///* int main(){    */
    CodeGenFunction::StartFunction(GD, ResTy, Fn, FnInfo, Args, Loc, BodyRange.getBegin())
    {
        CodeGenFunction::EmitFunctionProlog()
        {
            // If this- is an implicit-return-zero function, go ahead and
            // initialize the return value.  TODO: it might be nice to have
            // a more general mechanism for this that didn't require synthesized
            // return statements.
            if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) {
                if (FD->hasImplicitReturnZero()) {
                QualType RetTy = FD->getReturnType().getUnqualifiedType();
                llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
                llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
                Builder.CreateStore(Zero, ReturnValue);
                }
              }
        }
    }
    
    ///* printf("xxx"); */
    CodeGenFunction::EmitFunctionBody(const Stmt *Body)->
        CodeGenFunction::EmitCompoundStmtWithoutScop(const CompoundStmt &S,bool GetLast,AggValueSlot AggSlot)
        {
              for (auto *CurStmt : S.body())
                  EmitStmt(CurStmt);
        }
}

clang::CodeGen::CodeGenFunction::EmitStmt(const clang::Stmt * S, llvm::ArrayRef<...> Attrs)
 clang::CodeGen::CodeGenFunction::EmitCompoundStmtWithoutScope(const clang::CompoundStmt & S, bool GetLast, clang::CodeGen::AggValueSlot AggSlot)
 clang::CodeGen::CodeGenFunction::EmitFunctionBody(const clang::Stmt * Body)
 clang::CodeGen::CodeGenFunction::GenerateCode(clang::GlobalDecl GD, llvm::Function * Fn, const clang::CodeGen::CGFunctionInfo & FnInfo)
 clang::CodeGen::CodeGenModule::EmitGlobalFunctionDefinition(clang::GlobalDecl GD, llvm::GlobalValue * GV)
 clang::CodeGen::CodeGenModule::EmitGlobalDefinition(clang::GlobalDecl GD, llvm::GlobalValue * GV)
 clang::CodeGen::CodeGenModule::EmitGlobal(clang::GlobalDecl GD)
 clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl * D)

// prototype
#define FOREACH(pps,...) ...
// acutually params 
#define FOREACH(pps,it_operator,...)

// clang-format off
#define __Choose30th(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10,\
                     _11, _12, _13, _14, _15, _16, _17, _18, _19, _20,\
                     _21, _22, _23, _24, _25, _26, _27, _28, _29, _30,\
                    ...) _30
#define ID(_1, ...) _1
#define IDx(...) __VA_ARGS__
#define Callx(f, ...) ID(f(__VA_ARGS__))
#define CallxPPS(f, _1) ID(f _1)
#define FOREACH0(it_operator, pps, ...)
#define FOREACH1(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH0 (it_operator, pps, __VA_ARGS__))
#define FOREACH2(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH1 (it_operator, pps, __VA_ARGS__))
#define FOREACH3(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH2 (it_operator, pps, __VA_ARGS__))
#define FOREACH4(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH3 (it_operator, pps, __VA_ARGS__))
#define FOREACH5(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH4 (it_operator, pps, __VA_ARGS__))
#define FOREACH6(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH5 (it_operator, pps, __VA_ARGS__))
#define FOREACH7(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH6 (it_operator, pps, __VA_ARGS__))
#define FOREACH8(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH7 (it_operator, pps, __VA_ARGS__))
#define FOREACH9(it_operator, pps, _1, ...)  IDx(it_operator(pps, _1) FOREACH8 (it_operator, pps, __VA_ARGS__))
#define FOREACH10(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH9 (it_operator, pps, __VA_ARGS__))
#define FOREACH11(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH10(it_operator, pps, __VA_ARGS__))
#define FOREACH12(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH11(it_operator, pps, __VA_ARGS__))
#define FOREACH13(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH12(it_operator, pps, __VA_ARGS__))
#define FOREACH14(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH13(it_operator, pps, __VA_ARGS__))
#define FOREACH15(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH14(it_operator, pps, __VA_ARGS__))
#define FOREACH16(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH15(it_operator, pps, __VA_ARGS__))
#define FOREACH17(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH16(it_operator, pps, __VA_ARGS__))
#define FOREACH18(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH17(it_operator, pps, __VA_ARGS__))
#define FOREACH19(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH18(it_operator, pps, __VA_ARGS__))
#define FOREACH20(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH19(it_operator, pps, __VA_ARGS__))
#define FOREACH21(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH20(it_operator, pps, __VA_ARGS__))
#define FOREACH22(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH21(it_operator, pps, __VA_ARGS__))
#define FOREACH23(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH22(it_operator, pps, __VA_ARGS__))
#define FOREACH24(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH23(it_operator, pps, __VA_ARGS__))
#define FOREACH25(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH24(it_operator, pps, __VA_ARGS__))
#define FOREACH26(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH25(it_operator, pps, __VA_ARGS__))
#define FOREACH27(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH26(it_operator, pps, __VA_ARGS__))
#define FOREACH28(it_operator, pps, _1, ...) IDx(it_operator(pps, _1) FOREACH27(it_operator, pps, __VA_ARGS__))
// clang-format on
#define FOREACH(pps, ...)           \
    ID(__Choose30th(__VA_ARGS__,    \
                    FOREACH28,      \
                    FOREACH27,      \
                    FOREACH26,      \
                    FOREACH25,      \
                    FOREACH24,      \
                    FOREACH23,      \
                    FOREACH22,      \
                    FOREACH21,      \
                    FOREACH20,      \
                    FOREACH19,      \
                    FOREACH18,      \
                    FOREACH17,      \
                    FOREACH16,      \
                    FOREACH15,      \
                    FOREACH14,      \
                    FOREACH13,      \
                    FOREACH12,      \
                    FOREACH11,      \
                    FOREACH10,      \
                    FOREACH9,       \
                    FOREACH8,       \
                    FOREACH7,       \
                    FOREACH6,       \
                    FOREACH5,       \
                    FOREACH4,       \
                    FOREACH3,       \
                    FOREACH2,       \
                    FOREACH1,       \
                    FOREACH0))      \
    IDx((pps, __VA_ARGS__))

#define __EqualToPlain(x, y) || (x == y)
#define __EqualToPacket(px, y) Callx(__EqualToPlain, IDx px, y)
#define EqualToAnyOf(val, ...) 0 FOREACH(__EqualToPacket, (val), __VA_ARGS__)

#define MAKE_ENUM_Declare(ClsName,...) enum class ClsName{__VA_ARGS__};
#define MAKE_ENUM_ITEM_Begin(ClsName) \
    const char *GetStr(ClsName e)     \
    {                                 \
        switch (e)                    \
        {
#define MAKE_ENUM_ITEM(ClsName, Prefix, name) \
    case ClsName::name:                       \
        return Prefix #name;
// #define MAKE_ENUM_ITEM_PPS(pps, item) CallxPPS( Callx,(MAKE_ENUM_ITEM, IDx pps, item))
#define MAKE_ENUM_ITEM_PPS(pps, item) Callx(MAKE_ENUM_ITEM, IDx pps, item)
#define MAKE_ENUM_ITEM_End(ClsName, Prefix) \
    default:                                \
        return Prefix "";                   \
        }                                   \
        }
#define MAKE_ENUM(ClsName, Prefix, ...)                               \
    MAKE_ENUM_Declare(ClsName, __VA_ARGS__)                           \
    MAKE_ENUM_ITEM_Begin(ClsName)                                     \
    IDx(FOREACH(MAKE_ENUM_ITEM_PPS, (ClsName, Prefix), __VA_ARGS__))  \
    MAKE_ENUM_ITEM_End(ClsName, Prefix);

struct Visitor;// forward declaration
struct Obj{
virtual void Accept(Visitor *v);
};

struct OA;// forward declaration also
struct OB;
struct OB;

struct Visitor{
  virtual void AcceptOA(OA*o);
  virtual void AcceptOB(OB*o);
  virtual void AcceptOC(OC*o);
  // may OD OE
};

struct OA:public Obj{
  void Accept(Visitor *v)override{
    v->AcceptOA(this);
  }
};
struct OB:public Obj{
  void Accept(Visitor *v)override{
    v->AcceptOB(this);
  }
};
struct OC:public Obj{
  void Accept(Visitor *v)override{
    v->AcceptOC(this);
  }
};

struct PrintNameVisitor{
  virtual void AcceptOA(OA*o)override{ printf("PrintNameVisitor::AcceptOA(%x))\n",o); }
  virtual void AcceptOB(OB*o)override{ printf("PrintNameVisitor::AcceptOB(%x))\n",o); }
  virtual void AcceptOC(OC*o)override{ printf("PrintNameVisitor::AcceptOC(%x))\n",o); }
}

struct Visitor* vis = new PrintNameVisitor;
struct Obj o =new ObjA;
// 注意此处 vis 和 o 都是接口
o->Accept(&vis);

void OA::Accept(Visitor *vis)override{
  vis->AcceptOA(this);
}

// user code
arg0->Dispatch(I0 arg0, I1 arg1, In argn...);
// 第一次分派之后进入 , 得知 arg0 具体类型，调用 I1::DispatchC0
ConcreteArg0::Dispath(I0 arg0,I1 arg1,In argn...){
  arg1->DispatchC0(arg0,arg1,argn...);
}
// 第二次分派之后进入，此时再次得知 arg1 具体类型, 调用I1::DispatchC0C1
ConcreteArg1::DispatchC0(arg0,arg1,argn...){
  arg2->DispatchC0C1(arg0,arg1,argn...);
}
// 最终进入,这里的所有参数都是具体类型的
ConcreteArgn::DispatchC0C1Cn(arg0,arg1,argn...){
}

 struct Base{
  void what(){};
 };
 struct Derived:public Base{
  void what(){
    Base::what();
    ...;
  };
 }
int main(){
  // Base
  Base b;
  b.what();

  // Der
  Derived d;
  d.what();
  d.Base::what();
}

struct VBase{
  virtual void what(){};
};
struct VDerived:public VBase{
  virtual void what()override{
    VBase::what();
    ...
  }
}

void doWhat(VBase & base){
  base.what();
}
int main(){
  VBase b;
  vDerived d;

  doWhat(b);
  doWhat(d);
}