RZ_API bool rz_core_analysis_everything(RzCore *core, bool experimental, char *dh_orig) {
	bool didAap = false;
	ut64 curseek = core->offset;
	bool cfg_debug = rz_config_get_b(core->config, "cfg.debug");
	const char *oldstr = NULL;
	if (rz_str_startswith(rz_config_get(core->config, "bin.lang"), "go")) {
		oldstr = rz_print_rowlog(core->print, "Find function and symbol names from golang binaries (aang)");
		rz_print_rowlog_done(core->print, oldstr);
		rz_core_analysis_autoname_all_golang_fcns(core);
		oldstr = rz_print_rowlog(core->print, "Analyze all flags starting with sym.go. (aF @@f:sym.go.*)");
		rz_core_cmd0(core, "aF @@f:sym.go.*");
		rz_print_rowlog_done(core->print, oldstr);
	}
	rz_core_task_yield(&core->tasks);
	if (!cfg_debug) {
		if (dh_orig && strcmp(dh_orig, "esil")) {
			rz_config_set(core->config, "dbg.backend", "esil");
			rz_core_task_yield(&core->tasks);
		}
	}
	int c = rz_config_get_i(core->config, "analysis.calls");
	rz_config_set_i(core->config, "analysis.calls", 1);
	ut64 t = rz_num_math(core->num, "$S");
	rz_core_seek(core, t, true);
	if (rz_cons_is_breaked()) {
		return false;
	}

	oldstr = rz_print_rowlog(core->print, "Analyze function calls (aac)");
	(void)rz_cmd_analysis_calls(core, "", false, false); // "aac"
	rz_core_seek(core, curseek, true);
	rz_print_rowlog_done(core->print, oldstr);
	rz_core_task_yield(&core->tasks);
	if (rz_cons_is_breaked()) {
		return false;
	}

	if (is_unknown_file(core)) {
		oldstr = rz_print_rowlog(core->print, "find and analyze function preludes (aap)");
		(void)rz_core_search_preludes(core, false); // "aap"
		didAap = true;
		rz_print_rowlog_done(core->print, oldstr);
		rz_core_task_yield(&core->tasks);
		if (rz_cons_is_breaked()) {
			return false;
		}
	}

	oldstr = rz_print_rowlog(core->print, "Analyze len bytes of instructions for references (aar)");
	(void)rz_core_analysis_refs(core, ""); // "aar"
	rz_print_rowlog_done(core->print, oldstr);
	rz_core_task_yield(&core->tasks);
	if (rz_cons_is_breaked()) {
		return false;
	}
	if (is_apple_target(core)) {
		oldstr = rz_print_rowlog(core->print, "Check for objc references");
		rz_print_rowlog_done(core->print, oldstr);
		cmd_analysis_objc(core, true);
	}
	rz_core_task_yield(&core->tasks);
	oldstr = rz_print_rowlog(core->print, "Check for classes");
	rz_analysis_class_recover_all(core->analysis);
	rz_print_rowlog_done(core->print, oldstr);
	rz_core_task_yield(&core->tasks);
	rz_config_set_i(core->config, "analysis.calls", c);
	rz_core_task_yield(&core->tasks);
	if (rz_cons_is_breaked()) {
		return false;
	}
	if (!rz_str_startswith(rz_config_get(core->config, "asm.arch"), "x86")) {
		rz_core_analysis_value_pointers(core, RZ_OUTPUT_MODE_STANDARD);
		rz_core_task_yield(&core->tasks);
		bool pcache = rz_config_get_b(core->config, "io.pcache");
		rz_config_set_b(core->config, "io.pcache", false);
		oldstr = rz_print_rowlog(core->print, "Emulate functions to find computed references (aaef)");
		rz_core_analysis_esil_references_all_functions(core);
		rz_print_rowlog_done(core->print, oldstr);
		rz_core_task_yield(&core->tasks);
		rz_config_set_b(core->config, "io.pcache", pcache);
		if (rz_cons_is_breaked()) {
			return false;
		}
	}
	if (rz_config_get_i(core->config, "analysis.autoname")) {
		oldstr = rz_print_rowlog(core->print, "Speculatively constructing a function name "
						      "for fcn.* and sym.func.* functions (aan)");
		rz_core_analysis_autoname_all_fcns(core);
		rz_print_rowlog_done(core->print, oldstr);
		rz_core_task_yield(&core->tasks);
	}
	if (core->analysis->opt.vars) {
		RzAnalysisFunction *fcni;
		RzListIter *iter;
		rz_list_foreach (core->analysis->fcns, iter, fcni) {
			if (rz_cons_is_breaked()) {
				break;
			}
			RzList *list = rz_analysis_var_list(core->analysis, fcni, 'r');
			if (!rz_list_empty(list)) {
				rz_list_free(list);
				continue;
			}
			//extract only reg based var here
			rz_core_recover_vars(core, fcni, true);
			rz_list_free(list);
		}
		rz_core_task_yield(&core->tasks);
	}
	if (!sdb_isempty(core->analysis->sdb_zigns)) {
		oldstr = rz_print_rowlog(core->print, "Check for zignature from zigns folder (z/)");
		rz_core_cmd0(core, "z/");
		rz_print_rowlog_done(core->print, oldstr);
		rz_core_task_yield(&core->tasks);
	}

	oldstr = rz_print_rowlog(core->print, "Type matching analysis for all functions (aaft)");
	rz_core_analysis_types_propagation(core);
	rz_print_rowlog_done(core->print, oldstr);
	rz_core_task_yield(&core->tasks);

	oldstr = rz_print_rowlog(core->print, "Propagate noreturn information");
	rz_core_analysis_propagate_noreturn(core, UT64_MAX);
	rz_print_rowlog_done(core->print, oldstr);
	rz_core_task_yield(&core->tasks);

	// Apply DWARF function information
	Sdb *dwarf_sdb = sdb_ns(core->analysis->sdb, "dwarf", 0);
	if (dwarf_sdb) {
		oldstr = rz_print_rowlog(core->print, "Integrate dwarf function information.");
		rz_analysis_dwarf_integrate_functions(core->analysis, core->flags, dwarf_sdb);
		rz_print_rowlog_done(core->print, oldstr);
	}

	oldstr = rz_print_rowlog(core->print, "Use -AA or aaaa to perform additional experimental analysis.");
	rz_print_rowlog_done(core->print, oldstr);

	if (experimental) {
		if (!didAap) {
			oldstr = rz_print_rowlog(core->print, "Finding function preludes");
			(void)rz_core_search_preludes(core, false); // "aap"
			rz_print_rowlog_done(core->print, oldstr);
			rz_core_task_yield(&core->tasks);
		}

		oldstr = rz_print_rowlog(core->print, "Enable constraint types analysis for variables");
		rz_config_set(core->config, "analysis.types.constraint", "true");
		rz_print_rowlog_done(core->print, oldstr);
	}
	rz_core_seek_undo(core);
	if (dh_orig) {
		rz_config_set(core->config, "dbg.backend", dh_orig);
		rz_core_task_yield(&core->tasks);
	}
	if (!is_unknown_file(core)) {
		rz_analysis_add_device_peripheral_map(core->bin->cur->o, core->analysis);
	}
	return true;
}