//This file is automatically generated by generator.lua from https://github.com/cimgui/cimplot
//based on implot.h file version 0.17 from implot https://github.com/epezent/implot
//with implot_internal.h api

#include "./implot/implot.h"
#include "./implot/implot_internal.h"
#include "cimplot.h"

//ImPlotPoint getters manually wrapped for taking getters modifying ImPlotPoint*

ImPlotPoint_getter getter_funcX;
ImPlotPoint_getter getter_funcX2;

ImPlotPoint Wrapper(int idx, void* data)
{
	ImPlotPoint pp;
	getter_funcX(data, idx, reinterpret_cast<ImPlotPoint_c*>(&pp));
	return pp;
}

ImPlotPoint Wrapper2(int idx, void* data)
{
	ImPlotPoint pp;
	getter_funcX2(data, idx, reinterpret_cast<ImPlotPoint_c*>(&pp));
	return pp;
}

static inline ImPlotAxis ConvertToCPP_ImPlotAxis(const ImPlotAxis_c& src)
{
    ImPlotAxis dest;
    dest.ID = src.ID;
    dest.Flags = src.Flags;
    dest.PreviousFlags = src.PreviousFlags;
    dest.Range.Min = src.Range.Min;
    dest.Range.Max = src.Range.Max;
    dest.RangeCond = src.RangeCond;
    dest.Scale = src.Scale;
    dest.FitExtents.Min = src.FitExtents.Min;
    dest.FitExtents.Max = src.FitExtents.Max;
    dest.OrthoAxis = reinterpret_cast<ImPlotAxis*>(src.OrthoAxis);
    dest.ConstraintRange.Min = src.ConstraintRange.Min;
    dest.ConstraintRange.Max = src.ConstraintRange.Max;
    dest.ConstraintZoom.Min = src.ConstraintZoom.Min;
    dest.ConstraintZoom.Max = src.ConstraintZoom.Max;
    dest.Ticker = src.Ticker;
    dest.Formatter = src.Formatter;
    dest.FormatterData = src.FormatterData;
    dest.FormatSpec[16] = src.FormatSpec[16];
    dest.Locator = src.Locator;
    dest.LinkedMin = src.LinkedMin;
    dest.LinkedMax = src.LinkedMax;
    dest.PickerLevel = src.PickerLevel;
    dest.PickerTimeMin.S = src.PickerTimeMin.S;
    dest.PickerTimeMin.Us = src.PickerTimeMin.Us;
    dest.PickerTimeMax.S = src.PickerTimeMax.S;
    dest.PickerTimeMax.Us = src.PickerTimeMax.Us;
    dest.TransformForward = src.TransformForward;
    dest.TransformInverse = src.TransformInverse;
    dest.TransformData = src.TransformData;
    dest.PixelMin = src.PixelMin;
    dest.PixelMax = src.PixelMax;
    dest.ScaleMin = src.ScaleMin;
    dest.ScaleMax = src.ScaleMax;
    dest.ScaleToPixel = src.ScaleToPixel;
    dest.Datum1 = src.Datum1;
    dest.Datum2 = src.Datum2;
    dest.HoverRect.Min.x = src.HoverRect.Min.x;
    dest.HoverRect.Min.y = src.HoverRect.Min.y;
    dest.HoverRect.Max.x = src.HoverRect.Max.x;
    dest.HoverRect.Max.y = src.HoverRect.Max.y;
    dest.LabelOffset = src.LabelOffset;
    dest.ColorMaj = src.ColorMaj;
    dest.ColorMin = src.ColorMin;
    dest.ColorTick = src.ColorTick;
    dest.ColorTxt = src.ColorTxt;
    dest.ColorBg = src.ColorBg;
    dest.ColorHov = src.ColorHov;
    dest.ColorAct = src.ColorAct;
    dest.ColorHiLi = src.ColorHiLi;
    dest.Enabled = src.Enabled;
    dest.Vertical = src.Vertical;
    dest.FitThisFrame = src.FitThisFrame;
    dest.HasRange = src.HasRange;
    dest.HasFormatSpec = src.HasFormatSpec;
    dest.ShowDefaultTicks = src.ShowDefaultTicks;
    dest.Hovered = src.Hovered;
    dest.Held = src.Held;
    return dest;
}
static inline ImPlotAxis_c ConvertFromCPP_ImPlotAxis(const ImPlotAxis& src)
{
    ImPlotAxis_c dest;
    dest.ID = src.ID;
    dest.Flags = src.Flags;
    dest.PreviousFlags = src.PreviousFlags;
    dest.Range.Min = src.Range.Min;
    dest.Range.Max = src.Range.Max;
    dest.RangeCond = src.RangeCond;
    dest.Scale = src.Scale;
    dest.FitExtents.Min = src.FitExtents.Min;
    dest.FitExtents.Max = src.FitExtents.Max;
    dest.OrthoAxis = reinterpret_cast<ImPlotAxis_c*>(src.OrthoAxis);
    dest.ConstraintRange.Min = src.ConstraintRange.Min;
    dest.ConstraintRange.Max = src.ConstraintRange.Max;
    dest.ConstraintZoom.Min = src.ConstraintZoom.Min;
    dest.ConstraintZoom.Max = src.ConstraintZoom.Max;
    dest.Ticker = src.Ticker;
    dest.Formatter = src.Formatter;
    dest.FormatterData = src.FormatterData;
    dest.FormatSpec[16] = src.FormatSpec[16];
    dest.Locator = src.Locator;
    dest.LinkedMin = src.LinkedMin;
    dest.LinkedMax = src.LinkedMax;
    dest.PickerLevel = src.PickerLevel;
    dest.PickerTimeMin.S = src.PickerTimeMin.S;
    dest.PickerTimeMin.Us = src.PickerTimeMin.Us;
    dest.PickerTimeMax.S = src.PickerTimeMax.S;
    dest.PickerTimeMax.Us = src.PickerTimeMax.Us;
    dest.TransformForward = src.TransformForward;
    dest.TransformInverse = src.TransformInverse;
    dest.TransformData = src.TransformData;
    dest.PixelMin = src.PixelMin;
    dest.PixelMax = src.PixelMax;
    dest.ScaleMin = src.ScaleMin;
    dest.ScaleMax = src.ScaleMax;
    dest.ScaleToPixel = src.ScaleToPixel;
    dest.Datum1 = src.Datum1;
    dest.Datum2 = src.Datum2;
    dest.HoverRect.Min.x = src.HoverRect.Min.x;
    dest.HoverRect.Min.y = src.HoverRect.Min.y;
    dest.HoverRect.Max.x = src.HoverRect.Max.x;
    dest.HoverRect.Max.y = src.HoverRect.Max.y;
    dest.LabelOffset = src.LabelOffset;
    dest.ColorMaj = src.ColorMaj;
    dest.ColorMin = src.ColorMin;
    dest.ColorTick = src.ColorTick;
    dest.ColorTxt = src.ColorTxt;
    dest.ColorBg = src.ColorBg;
    dest.ColorHov = src.ColorHov;
    dest.ColorAct = src.ColorAct;
    dest.ColorHiLi = src.ColorHiLi;
    dest.Enabled = src.Enabled;
    dest.Vertical = src.Vertical;
    dest.FitThisFrame = src.FitThisFrame;
    dest.HasRange = src.HasRange;
    dest.HasFormatSpec = src.HasFormatSpec;
    dest.ShowDefaultTicks = src.ShowDefaultTicks;
    dest.Hovered = src.Hovered;
    dest.Held = src.Held;
    return dest;
}
static inline ImPlotDateTimeSpec ConvertToCPP_ImPlotDateTimeSpec(const ImPlotDateTimeSpec_c& src)
{
    ImPlotDateTimeSpec dest;
    dest.Date = src.Date;
    dest.Time = src.Time;
    dest.UseISO8601 = src.UseISO8601;
    dest.Use24HourClock = src.Use24HourClock;
    return dest;
}
static inline ImPlotDateTimeSpec_c ConvertFromCPP_ImPlotDateTimeSpec(const ImPlotDateTimeSpec& src)
{
    ImPlotDateTimeSpec_c dest;
    dest.Date = src.Date;
    dest.Time = src.Time;
    dest.UseISO8601 = src.UseISO8601;
    dest.Use24HourClock = src.Use24HourClock;
    return dest;
}
static inline ImPlotPoint ConvertToCPP_ImPlotPoint(const ImPlotPoint_c& src)
{
    ImPlotPoint dest;
    dest.x = src.x;
    dest.y = src.y;
    return dest;
}
static inline ImPlotPoint_c ConvertFromCPP_ImPlotPoint(const ImPlotPoint& src)
{
    ImPlotPoint_c dest;
    dest.x = src.x;
    dest.y = src.y;
    return dest;
}
static inline ImPlotRange ConvertToCPP_ImPlotRange(const ImPlotRange_c& src)
{
    ImPlotRange dest;
    dest.Min = src.Min;
    dest.Max = src.Max;
    return dest;
}
static inline ImPlotRange_c ConvertFromCPP_ImPlotRange(const ImPlotRange& src)
{
    ImPlotRange_c dest;
    dest.Min = src.Min;
    dest.Max = src.Max;
    return dest;
}
static inline ImPlotRect ConvertToCPP_ImPlotRect(const ImPlotRect_c& src)
{
    ImPlotRect dest;
    dest.X.Min = src.X.Min;
    dest.X.Max = src.X.Max;
    dest.Y.Min = src.Y.Min;
    dest.Y.Max = src.Y.Max;
    return dest;
}
static inline ImPlotRect_c ConvertFromCPP_ImPlotRect(const ImPlotRect& src)
{
    ImPlotRect_c dest;
    dest.X.Min = src.X.Min;
    dest.X.Max = src.X.Max;
    dest.Y.Min = src.Y.Min;
    dest.Y.Max = src.Y.Max;
    return dest;
}
static inline ImPlotTick ConvertToCPP_ImPlotTick(const ImPlotTick_c& src)
{
    ImPlotTick dest;
    dest.PlotPos = src.PlotPos;
    dest.PixelPos = src.PixelPos;
    dest.LabelSize.x = src.LabelSize.x;
    dest.LabelSize.y = src.LabelSize.y;
    dest.TextOffset = src.TextOffset;
    dest.Major = src.Major;
    dest.ShowLabel = src.ShowLabel;
    dest.Level = src.Level;
    dest.Idx = src.Idx;
    return dest;
}
static inline ImPlotTick_c ConvertFromCPP_ImPlotTick(const ImPlotTick& src)
{
    ImPlotTick_c dest;
    dest.PlotPos = src.PlotPos;
    dest.PixelPos = src.PixelPos;
    dest.LabelSize.x = src.LabelSize.x;
    dest.LabelSize.y = src.LabelSize.y;
    dest.TextOffset = src.TextOffset;
    dest.Major = src.Major;
    dest.ShowLabel = src.ShowLabel;
    dest.Level = src.Level;
    dest.Idx = src.Idx;
    return dest;
}
static inline ImPlotTime ConvertToCPP_ImPlotTime(const ImPlotTime_c& src)
{
    ImPlotTime dest;
    dest.S = src.S;
    dest.Us = src.Us;
    return dest;
}
static inline ImPlotTime_c ConvertFromCPP_ImPlotTime(const ImPlotTime& src)
{
    ImPlotTime_c dest;
    dest.S = src.S;
    dest.Us = src.Us;
    return dest;
}
static inline ImRect ConvertToCPP_ImRect(const ImRect_c& src)
{
    ImRect dest;
    dest.Min.x = src.Min.x;
    dest.Min.y = src.Min.y;
    dest.Max.x = src.Max.x;
    dest.Max.y = src.Max.y;
    return dest;
}
static inline ImRect_c ConvertFromCPP_ImRect(const ImRect& src)
{
    ImRect_c dest;
    dest.Min.x = src.Min.x;
    dest.Min.y = src.Min.y;
    dest.Max.x = src.Max.x;
    dest.Max.y = src.Max.y;
    return dest;
}
static inline ImTextureRef ConvertToCPP_ImTextureRef(const ImTextureRef_c& src)
{
    ImTextureRef dest;
    dest._TexData = src._TexData;
    dest._TexID = src._TexID;
    return dest;
}
static inline ImTextureRef_c ConvertFromCPP_ImTextureRef(const ImTextureRef& src)
{
    ImTextureRef_c dest;
    dest._TexData = src._TexData;
    dest._TexID = src._TexID;
    return dest;
}
static inline ImVec2 ConvertToCPP_ImVec2(const ImVec2_c& src)
{
    ImVec2 dest;
    dest.x = src.x;
    dest.y = src.y;
    return dest;
}
static inline ImVec2_c ConvertFromCPP_ImVec2(const ImVec2& src)
{
    ImVec2_c dest;
    dest.x = src.x;
    dest.y = src.y;
    return dest;
}
static inline ImVec4 ConvertToCPP_ImVec4(const ImVec4_c& src)
{
    ImVec4 dest;
    dest.x = src.x;
    dest.y = src.y;
    dest.z = src.z;
    dest.w = src.w;
    return dest;
}
static inline ImVec4_c ConvertFromCPP_ImVec4(const ImVec4& src)
{
    ImVec4_c dest;
    dest.x = src.x;
    dest.y = src.y;
    dest.z = src.z;
    dest.w = src.w;
    return dest;
}CIMGUI_API ImPlotPoint* ImPlotPoint_ImPlotPoint_Nil(void)
{
    return IM_NEW(ImPlotPoint)();
}
CIMGUI_API void ImPlotPoint_destroy(ImPlotPoint* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotPoint* ImPlotPoint_ImPlotPoint_double(double _x,double _y)
{
    return IM_NEW(ImPlotPoint)(_x,_y);
}
CIMGUI_API ImPlotPoint* ImPlotPoint_ImPlotPoint_Vec2(const ImVec2_c p)
{
    return IM_NEW(ImPlotPoint)(ConvertToCPP_ImVec2(p));
}
CIMGUI_API ImPlotRange* ImPlotRange_ImPlotRange_Nil(void)
{
    return IM_NEW(ImPlotRange)();
}
CIMGUI_API void ImPlotRange_destroy(ImPlotRange* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotRange* ImPlotRange_ImPlotRange_double(double _min,double _max)
{
    return IM_NEW(ImPlotRange)(_min,_max);
}
CIMGUI_API bool ImPlotRange_Contains(ImPlotRange* self,double value)
{
    return self->Contains(value);
}
CIMGUI_API double ImPlotRange_Size(ImPlotRange* self)
{
    return self->Size();
}
CIMGUI_API double ImPlotRange_Clamp(ImPlotRange* self,double value)
{
    return self->Clamp(value);
}
CIMGUI_API ImPlotRect* ImPlotRect_ImPlotRect_Nil(void)
{
    return IM_NEW(ImPlotRect)();
}
CIMGUI_API void ImPlotRect_destroy(ImPlotRect* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotRect* ImPlotRect_ImPlotRect_double(double x_min,double x_max,double y_min,double y_max)
{
    return IM_NEW(ImPlotRect)(x_min,x_max,y_min,y_max);
}
CIMGUI_API bool ImPlotRect_Contains_PlotPoInt(ImPlotRect* self,const ImPlotPoint_c p)
{
    return self->Contains(ConvertToCPP_ImPlotPoint(p));
}
CIMGUI_API bool ImPlotRect_Contains_double(ImPlotRect* self,double x,double y)
{
    return self->Contains(x,y);
}
CIMGUI_API ImPlotPoint_c ImPlotRect_Size(ImPlotRect* self)
{
    return ConvertFromCPP_ImPlotPoint(self->Size());
}
CIMGUI_API ImPlotPoint_c ImPlotRect_Clamp_PlotPoInt(ImPlotRect* self,const ImPlotPoint_c p)
{
    return ConvertFromCPP_ImPlotPoint(self->Clamp(ConvertToCPP_ImPlotPoint(p)));
}
CIMGUI_API ImPlotPoint_c ImPlotRect_Clamp_double(ImPlotRect* self,double x,double y)
{
    return ConvertFromCPP_ImPlotPoint(self->Clamp(x,y));
}
CIMGUI_API ImPlotPoint_c ImPlotRect_Min(ImPlotRect* self)
{
    return ConvertFromCPP_ImPlotPoint(self->Min());
}
CIMGUI_API ImPlotPoint_c ImPlotRect_Max(ImPlotRect* self)
{
    return ConvertFromCPP_ImPlotPoint(self->Max());
}
CIMGUI_API ImPlotStyle* ImPlotStyle_ImPlotStyle(void)
{
    return IM_NEW(ImPlotStyle)();
}
CIMGUI_API void ImPlotStyle_destroy(ImPlotStyle* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotInputMap* ImPlotInputMap_ImPlotInputMap(void)
{
    return IM_NEW(ImPlotInputMap)();
}
CIMGUI_API void ImPlotInputMap_destroy(ImPlotInputMap* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotContext* ImPlot_CreateContext()
{
    return ImPlot::CreateContext();
}
CIMGUI_API void ImPlot_DestroyContext(ImPlotContext* ctx)
{
    return ImPlot::DestroyContext(ctx);
}
CIMGUI_API ImPlotContext* ImPlot_GetCurrentContext()
{
    return ImPlot::GetCurrentContext();
}
CIMGUI_API void ImPlot_SetCurrentContext(ImPlotContext* ctx)
{
    return ImPlot::SetCurrentContext(ctx);
}
CIMGUI_API void ImPlot_SetImGuiContext(ImGuiContext* ctx)
{
    return ImPlot::SetImGuiContext(ctx);
}
CIMGUI_API bool ImPlot_BeginPlot(const char* title_id,const ImVec2_c size,ImPlotFlags flags)
{
    return ImPlot::BeginPlot(title_id,ConvertToCPP_ImVec2(size),flags);
}
CIMGUI_API void ImPlot_EndPlot()
{
    return ImPlot::EndPlot();
}
CIMGUI_API bool ImPlot_BeginSubplots(const char* title_id,int rows,int cols,const ImVec2_c size,ImPlotSubplotFlags flags,float* row_ratios,float* col_ratios)
{
    return ImPlot::BeginSubplots(title_id,rows,cols,ConvertToCPP_ImVec2(size),flags,row_ratios,col_ratios);
}
CIMGUI_API void ImPlot_EndSubplots()
{
    return ImPlot::EndSubplots();
}
CIMGUI_API void ImPlot_SetupAxis(ImAxis axis,const char* label,ImPlotAxisFlags flags)
{
    return ImPlot::SetupAxis(axis,label,flags);
}
CIMGUI_API void ImPlot_SetupAxisLimits(ImAxis axis,double v_min,double v_max,ImPlotCond cond)
{
    return ImPlot::SetupAxisLimits(axis,v_min,v_max,cond);
}
CIMGUI_API void ImPlot_SetupAxisLinks(ImAxis axis,double* link_min,double* link_max)
{
    return ImPlot::SetupAxisLinks(axis,link_min,link_max);
}
CIMGUI_API void ImPlot_SetupAxisFormat_Str(ImAxis axis,const char* fmt)
{
    return ImPlot::SetupAxisFormat(axis,fmt);
}
CIMGUI_API void ImPlot_SetupAxisFormat_PlotFormatter(ImAxis axis,ImPlotFormatter formatter,void* data)
{
    return ImPlot::SetupAxisFormat(axis,formatter,data);
}
CIMGUI_API void ImPlot_SetupAxisTicks_doublePtr(ImAxis axis,const double* values,int n_ticks,const char* const labels[],bool keep_default)
{
    return ImPlot::SetupAxisTicks(axis,values,n_ticks,labels,keep_default);
}
CIMGUI_API void ImPlot_SetupAxisTicks_double(ImAxis axis,double v_min,double v_max,int n_ticks,const char* const labels[],bool keep_default)
{
    return ImPlot::SetupAxisTicks(axis,v_min,v_max,n_ticks,labels,keep_default);
}
CIMGUI_API void ImPlot_SetupAxisScale_PlotScale(ImAxis axis,ImPlotScale scale)
{
    return ImPlot::SetupAxisScale(axis,scale);
}
CIMGUI_API void ImPlot_SetupAxisScale_PlotTransform(ImAxis axis,ImPlotTransform forward,ImPlotTransform inverse,void* data)
{
    return ImPlot::SetupAxisScale(axis,forward,inverse,data);
}
CIMGUI_API void ImPlot_SetupAxisLimitsConstraints(ImAxis axis,double v_min,double v_max)
{
    return ImPlot::SetupAxisLimitsConstraints(axis,v_min,v_max);
}
CIMGUI_API void ImPlot_SetupAxisZoomConstraints(ImAxis axis,double z_min,double z_max)
{
    return ImPlot::SetupAxisZoomConstraints(axis,z_min,z_max);
}
CIMGUI_API void ImPlot_SetupAxes(const char* x_label,const char* y_label,ImPlotAxisFlags x_flags,ImPlotAxisFlags y_flags)
{
    return ImPlot::SetupAxes(x_label,y_label,x_flags,y_flags);
}
CIMGUI_API void ImPlot_SetupAxesLimits(double x_min,double x_max,double y_min,double y_max,ImPlotCond cond)
{
    return ImPlot::SetupAxesLimits(x_min,x_max,y_min,y_max,cond);
}
CIMGUI_API void ImPlot_SetupLegend(ImPlotLocation location,ImPlotLegendFlags flags)
{
    return ImPlot::SetupLegend(location,flags);
}
CIMGUI_API void ImPlot_SetupMouseText(ImPlotLocation location,ImPlotMouseTextFlags flags)
{
    return ImPlot::SetupMouseText(location,flags);
}
CIMGUI_API void ImPlot_SetupFinish()
{
    return ImPlot::SetupFinish();
}
CIMGUI_API void ImPlot_SetNextAxisLimits(ImAxis axis,double v_min,double v_max,ImPlotCond cond)
{
    return ImPlot::SetNextAxisLimits(axis,v_min,v_max,cond);
}
CIMGUI_API void ImPlot_SetNextAxisLinks(ImAxis axis,double* link_min,double* link_max)
{
    return ImPlot::SetNextAxisLinks(axis,link_min,link_max);
}
CIMGUI_API void ImPlot_SetNextAxisToFit(ImAxis axis)
{
    return ImPlot::SetNextAxisToFit(axis);
}
CIMGUI_API void ImPlot_SetNextAxesLimits(double x_min,double x_max,double y_min,double y_max,ImPlotCond cond)
{
    return ImPlot::SetNextAxesLimits(x_min,x_max,y_min,y_max,cond);
}
CIMGUI_API void ImPlot_SetNextAxesToFit()
{
    return ImPlot::SetNextAxesToFit();
}
CIMGUI_API void ImPlot_PlotLine_FloatPtrInt(const char* label_id,const float* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_doublePtrInt(const char* label_id,const double* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S8PtrInt(const char* label_id,const ImS8* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U8PtrInt(const char* label_id,const ImU8* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S16PtrInt(const char* label_id,const ImS16* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U16PtrInt(const char* label_id,const ImU16* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S32PtrInt(const char* label_id,const ImS32* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U32PtrInt(const char* label_id,const ImU32* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S64PtrInt(const char* label_id,const ImS64* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U64PtrInt(const char* label_id,const ImU64* values,int count,double xscale,double xstart,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_FloatPtrFloatPtr(const char* label_id,const float* xs,const float* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_doublePtrdoublePtr(const char* label_id,const double* xs,const double* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S8PtrS8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U8PtrU8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S16PtrS16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U16PtrU16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S32PtrS32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U32PtrU32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_S64PtrS64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLine_U64PtrU64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotLineFlags flags,int offset,int stride)
{
    return ImPlot::PlotLine(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotLineG(const char* label_id,ImPlotPoint_getter getter,void* data,int count,ImPlotLineFlags flags)
{
    getter_funcX = getter;
    ImPlot::PlotLineG(label_id,Wrapper,data,count,flags);
}
CIMGUI_API void ImPlot_PlotScatter_FloatPtrInt(const char* label_id,const float* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_doublePtrInt(const char* label_id,const double* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S8PtrInt(const char* label_id,const ImS8* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U8PtrInt(const char* label_id,const ImU8* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S16PtrInt(const char* label_id,const ImS16* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U16PtrInt(const char* label_id,const ImU16* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S32PtrInt(const char* label_id,const ImS32* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U32PtrInt(const char* label_id,const ImU32* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S64PtrInt(const char* label_id,const ImS64* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U64PtrInt(const char* label_id,const ImU64* values,int count,double xscale,double xstart,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_FloatPtrFloatPtr(const char* label_id,const float* xs,const float* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_doublePtrdoublePtr(const char* label_id,const double* xs,const double* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S8PtrS8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U8PtrU8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S16PtrS16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U16PtrU16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S32PtrS32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U32PtrU32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_S64PtrS64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatter_U64PtrU64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotScatterFlags flags,int offset,int stride)
{
    return ImPlot::PlotScatter(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotScatterG(const char* label_id,ImPlotPoint_getter getter,void* data,int count,ImPlotScatterFlags flags)
{
    getter_funcX = getter;
    ImPlot::PlotScatterG(label_id,Wrapper,data,count,flags);
}
CIMGUI_API void ImPlot_PlotStairs_FloatPtrInt(const char* label_id,const float* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_doublePtrInt(const char* label_id,const double* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S8PtrInt(const char* label_id,const ImS8* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U8PtrInt(const char* label_id,const ImU8* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S16PtrInt(const char* label_id,const ImS16* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U16PtrInt(const char* label_id,const ImU16* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S32PtrInt(const char* label_id,const ImS32* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U32PtrInt(const char* label_id,const ImU32* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S64PtrInt(const char* label_id,const ImS64* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U64PtrInt(const char* label_id,const ImU64* values,int count,double xscale,double xstart,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,values,count,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_FloatPtrFloatPtr(const char* label_id,const float* xs,const float* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_doublePtrdoublePtr(const char* label_id,const double* xs,const double* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S8PtrS8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U8PtrU8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S16PtrS16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U16PtrU16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S32PtrS32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U32PtrU32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_S64PtrS64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairs_U64PtrU64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotStairsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStairs(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStairsG(const char* label_id,ImPlotPoint_getter getter,void* data,int count,ImPlotStairsFlags flags)
{
    getter_funcX = getter;
    ImPlot::PlotStairsG(label_id,Wrapper,data,count,flags);
}
CIMGUI_API void ImPlot_PlotShaded_FloatPtrInt(const char* label_id,const float* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_doublePtrInt(const char* label_id,const double* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S8PtrInt(const char* label_id,const ImS8* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U8PtrInt(const char* label_id,const ImU8* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S16PtrInt(const char* label_id,const ImS16* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U16PtrInt(const char* label_id,const ImU16* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S32PtrInt(const char* label_id,const ImS32* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U32PtrInt(const char* label_id,const ImU32* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S64PtrInt(const char* label_id,const ImS64* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U64PtrInt(const char* label_id,const ImU64* values,int count,double yref,double xscale,double xstart,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,values,count,yref,xscale,xstart,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_FloatPtrFloatPtrInt(const char* label_id,const float* xs,const float* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_doublePtrdoublePtrInt(const char* label_id,const double* xs,const double* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S8PtrS8PtrInt(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U8PtrU8PtrInt(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S16PtrS16PtrInt(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U16PtrU16PtrInt(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S32PtrS32PtrInt(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U32PtrU32PtrInt(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S64PtrS64PtrInt(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U64PtrU64PtrInt(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double yref,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys,count,yref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_FloatPtrFloatPtrFloatPtr(const char* label_id,const float* xs,const float* ys1,const float* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_doublePtrdoublePtrdoublePtr(const char* label_id,const double* xs,const double* ys1,const double* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S8PtrS8PtrS8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys1,const ImS8* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U8PtrU8PtrU8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys1,const ImU8* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S16PtrS16PtrS16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys1,const ImS16* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U16PtrU16PtrU16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys1,const ImU16* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S32PtrS32PtrS32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys1,const ImS32* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U32PtrU32PtrU32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys1,const ImU32* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_S64PtrS64PtrS64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys1,const ImS64* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShaded_U64PtrU64PtrU64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys1,const ImU64* ys2,int count,ImPlotShadedFlags flags,int offset,int stride)
{
    return ImPlot::PlotShaded(label_id,xs,ys1,ys2,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotShadedG(const char* label_id,ImPlotPoint_getter getter1,void* data1,ImPlotPoint_getter getter2,void* data2,int count,ImPlotShadedFlags flags)
{
    getter_funcX = getter1;
    getter_funcX2 = getter2;
    ImPlot::PlotShadedG(label_id,Wrapper,data1,Wrapper2,data2,count,flags);
}
CIMGUI_API void ImPlot_PlotBars_FloatPtrInt(const char* label_id,const float* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_doublePtrInt(const char* label_id,const double* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S8PtrInt(const char* label_id,const ImS8* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U8PtrInt(const char* label_id,const ImU8* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S16PtrInt(const char* label_id,const ImS16* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U16PtrInt(const char* label_id,const ImU16* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S32PtrInt(const char* label_id,const ImS32* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U32PtrInt(const char* label_id,const ImU32* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S64PtrInt(const char* label_id,const ImS64* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U64PtrInt(const char* label_id,const ImU64* values,int count,double bar_size,double shift,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,values,count,bar_size,shift,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_FloatPtrFloatPtr(const char* label_id,const float* xs,const float* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_doublePtrdoublePtr(const char* label_id,const double* xs,const double* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S8PtrS8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U8PtrU8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S16PtrS16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U16PtrU16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S32PtrS32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U32PtrU32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_S64PtrS64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBars_U64PtrU64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double bar_size,ImPlotBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotBars(label_id,xs,ys,count,bar_size,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotBarsG(const char* label_id,ImPlotPoint_getter getter,void* data,int count,double bar_size,ImPlotBarsFlags flags)
{
    getter_funcX = getter;
    ImPlot::PlotBarsG(label_id,Wrapper,data,count,bar_size,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_FloatPtr(const char* const label_ids[],const float* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_doublePtr(const char* const label_ids[],const double* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_S8Ptr(const char* const label_ids[],const ImS8* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_U8Ptr(const char* const label_ids[],const ImU8* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_S16Ptr(const char* const label_ids[],const ImS16* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_U16Ptr(const char* const label_ids[],const ImU16* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_S32Ptr(const char* const label_ids[],const ImS32* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_U32Ptr(const char* const label_ids[],const ImU32* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_S64Ptr(const char* const label_ids[],const ImS64* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotBarGroups_U64Ptr(const char* const label_ids[],const ImU64* values,int item_count,int group_count,double group_size,double shift,ImPlotBarGroupsFlags flags)
{
    return ImPlot::PlotBarGroups(label_ids,values,item_count,group_count,group_size,shift,flags);
}
CIMGUI_API void ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrInt(const char* label_id,const float* xs,const float* ys,const float* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrInt(const char* label_id,const double* xs,const double* ys,const double* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrInt(const char* label_id,const ImS8* xs,const ImS8* ys,const ImS8* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrInt(const char* label_id,const ImU8* xs,const ImU8* ys,const ImU8* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrInt(const char* label_id,const ImS16* xs,const ImS16* ys,const ImS16* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrInt(const char* label_id,const ImU16* xs,const ImU16* ys,const ImU16* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrInt(const char* label_id,const ImS32* xs,const ImS32* ys,const ImS32* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrInt(const char* label_id,const ImU32* xs,const ImU32* ys,const ImU32* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrInt(const char* label_id,const ImS64* xs,const ImS64* ys,const ImS64* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrInt(const char* label_id,const ImU64* xs,const ImU64* ys,const ImU64* err,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,err,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_FloatPtrFloatPtrFloatPtrFloatPtr(const char* label_id,const float* xs,const float* ys,const float* neg,const float* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_doublePtrdoublePtrdoublePtrdoublePtr(const char* label_id,const double* xs,const double* ys,const double* neg,const double* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S8PtrS8PtrS8PtrS8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,const ImS8* neg,const ImS8* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U8PtrU8PtrU8PtrU8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,const ImU8* neg,const ImU8* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S16PtrS16PtrS16PtrS16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,const ImS16* neg,const ImS16* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U16PtrU16PtrU16PtrU16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,const ImU16* neg,const ImU16* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S32PtrS32PtrS32PtrS32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,const ImS32* neg,const ImS32* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U32PtrU32PtrU32PtrU32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,const ImU32* neg,const ImU32* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_S64PtrS64PtrS64PtrS64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,const ImS64* neg,const ImS64* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotErrorBars_U64PtrU64PtrU64PtrU64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,const ImU64* neg,const ImU64* pos,int count,ImPlotErrorBarsFlags flags,int offset,int stride)
{
    return ImPlot::PlotErrorBars(label_id,xs,ys,neg,pos,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_FloatPtrInt(const char* label_id,const float* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_doublePtrInt(const char* label_id,const double* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S8PtrInt(const char* label_id,const ImS8* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U8PtrInt(const char* label_id,const ImU8* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S16PtrInt(const char* label_id,const ImS16* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U16PtrInt(const char* label_id,const ImU16* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S32PtrInt(const char* label_id,const ImS32* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U32PtrInt(const char* label_id,const ImU32* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S64PtrInt(const char* label_id,const ImS64* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U64PtrInt(const char* label_id,const ImU64* values,int count,double ref,double scale,double start,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,values,count,ref,scale,start,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_FloatPtrFloatPtr(const char* label_id,const float* xs,const float* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_doublePtrdoublePtr(const char* label_id,const double* xs,const double* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S8PtrS8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U8PtrU8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S16PtrS16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U16PtrU16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S32PtrS32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U32PtrU32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_S64PtrS64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotStems_U64PtrU64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,int count,double ref,ImPlotStemsFlags flags,int offset,int stride)
{
    return ImPlot::PlotStems(label_id,xs,ys,count,ref,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_FloatPtr(const char* label_id,const float* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_doublePtr(const char* label_id,const double* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_S8Ptr(const char* label_id,const ImS8* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_U8Ptr(const char* label_id,const ImU8* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_S16Ptr(const char* label_id,const ImS16* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_U16Ptr(const char* label_id,const ImU16* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_S32Ptr(const char* label_id,const ImS32* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_U32Ptr(const char* label_id,const ImU32* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_S64Ptr(const char* label_id,const ImS64* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotInfLines_U64Ptr(const char* label_id,const ImU64* values,int count,ImPlotInfLinesFlags flags,int offset,int stride)
{
    return ImPlot::PlotInfLines(label_id,values,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotPieChart_FloatPtrPlotFormatter(const char* const label_ids[],const float* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_doublePtrPlotFormatter(const char* const label_ids[],const double* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S8PtrPlotFormatter(const char* const label_ids[],const ImS8* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U8PtrPlotFormatter(const char* const label_ids[],const ImU8* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S16PtrPlotFormatter(const char* const label_ids[],const ImS16* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U16PtrPlotFormatter(const char* const label_ids[],const ImU16* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S32PtrPlotFormatter(const char* const label_ids[],const ImS32* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U32PtrPlotFormatter(const char* const label_ids[],const ImU32* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S64PtrPlotFormatter(const char* const label_ids[],const ImS64* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U64PtrPlotFormatter(const char* const label_ids[],const ImU64* values,int count,double x,double y,double radius,ImPlotFormatter fmt,void* fmt_data,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,fmt,fmt_data,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_FloatPtrStr(const char* const label_ids[],const float* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_doublePtrStr(const char* const label_ids[],const double* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S8PtrStr(const char* const label_ids[],const ImS8* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U8PtrStr(const char* const label_ids[],const ImU8* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S16PtrStr(const char* const label_ids[],const ImS16* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U16PtrStr(const char* const label_ids[],const ImU16* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S32PtrStr(const char* const label_ids[],const ImS32* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U32PtrStr(const char* const label_ids[],const ImU32* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_S64PtrStr(const char* const label_ids[],const ImS64* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotPieChart_U64PtrStr(const char* const label_ids[],const ImU64* values,int count,double x,double y,double radius,const char* label_fmt,double angle0,ImPlotPieChartFlags flags)
{
    return ImPlot::PlotPieChart(label_ids,values,count,x,y,radius,label_fmt,angle0,flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_FloatPtr(const char* label_id,const float* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_doublePtr(const char* label_id,const double* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_S8Ptr(const char* label_id,const ImS8* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_U8Ptr(const char* label_id,const ImU8* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_S16Ptr(const char* label_id,const ImS16* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_U16Ptr(const char* label_id,const ImU16* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_S32Ptr(const char* label_id,const ImS32* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_U32Ptr(const char* label_id,const ImU32* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_S64Ptr(const char* label_id,const ImS64* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API void ImPlot_PlotHeatmap_U64Ptr(const char* label_id,const ImU64* values,int rows,int cols,double scale_min,double scale_max,const char* label_fmt,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,ImPlotHeatmapFlags flags)
{
    return ImPlot::PlotHeatmap(label_id,values,rows,cols,scale_min,scale_max,label_fmt,ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_FloatPtr(const char* label_id,const float* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_doublePtr(const char* label_id,const double* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_S8Ptr(const char* label_id,const ImS8* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_U8Ptr(const char* label_id,const ImU8* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_S16Ptr(const char* label_id,const ImS16* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_U16Ptr(const char* label_id,const ImU16* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_S32Ptr(const char* label_id,const ImS32* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_U32Ptr(const char* label_id,const ImU32* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_S64Ptr(const char* label_id,const ImS64* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram_U64Ptr(const char* label_id,const ImU64* values,int count,int bins,double bar_scale,ImPlotRange_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram(label_id,values,count,bins,bar_scale,ConvertToCPP_ImPlotRange(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_FloatPtr(const char* label_id,const float* xs,const float* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_doublePtr(const char* label_id,const double* xs,const double* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_S8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_U8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_S16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_U16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_S32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_U32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_S64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API double ImPlot_PlotHistogram2D_U64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,int count,int x_bins,int y_bins,ImPlotRect_c range,ImPlotHistogramFlags flags)
{
    return ImPlot::PlotHistogram2D(label_id,xs,ys,count,x_bins,y_bins,ConvertToCPP_ImPlotRect(range),flags);
}
CIMGUI_API void ImPlot_PlotDigital_FloatPtr(const char* label_id,const float* xs,const float* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_doublePtr(const char* label_id,const double* xs,const double* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_S8Ptr(const char* label_id,const ImS8* xs,const ImS8* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_U8Ptr(const char* label_id,const ImU8* xs,const ImU8* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_S16Ptr(const char* label_id,const ImS16* xs,const ImS16* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_U16Ptr(const char* label_id,const ImU16* xs,const ImU16* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_S32Ptr(const char* label_id,const ImS32* xs,const ImS32* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_U32Ptr(const char* label_id,const ImU32* xs,const ImU32* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_S64Ptr(const char* label_id,const ImS64* xs,const ImS64* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigital_U64Ptr(const char* label_id,const ImU64* xs,const ImU64* ys,int count,ImPlotDigitalFlags flags,int offset,int stride)
{
    return ImPlot::PlotDigital(label_id,xs,ys,count,flags,offset,stride);
}
CIMGUI_API void ImPlot_PlotDigitalG(const char* label_id,ImPlotPoint_getter getter,void* data,int count,ImPlotDigitalFlags flags)
{
    getter_funcX = getter;
    ImPlot::PlotDigitalG(label_id,Wrapper,data,count,flags);
}
CIMGUI_API void ImPlot_PlotImage(const char* label_id,ImTextureRef_c tex_ref,const ImPlotPoint_c bounds_min,const ImPlotPoint_c bounds_max,const ImVec2_c uv0,const ImVec2_c uv1,const ImVec4_c tint_col,ImPlotImageFlags flags)
{
    return ImPlot::PlotImage(label_id,ConvertToCPP_ImTextureRef(tex_ref),ConvertToCPP_ImPlotPoint(bounds_min),ConvertToCPP_ImPlotPoint(bounds_max),ConvertToCPP_ImVec2(uv0),ConvertToCPP_ImVec2(uv1),ConvertToCPP_ImVec4(tint_col),flags);
}
CIMGUI_API void ImPlot_PlotText(const char* text,double x,double y,const ImVec2_c pix_offset,ImPlotTextFlags flags)
{
    return ImPlot::PlotText(text,x,y,ConvertToCPP_ImVec2(pix_offset),flags);
}
CIMGUI_API void ImPlot_PlotDummy(const char* label_id,ImPlotDummyFlags flags)
{
    return ImPlot::PlotDummy(label_id,flags);
}
CIMGUI_API bool ImPlot_DragPoint(int id,double* x,double* y,const ImVec4_c col,float size,ImPlotDragToolFlags flags,bool* out_clicked,bool* out_hovered,bool* out_held)
{
    return ImPlot::DragPoint(id,x,y,ConvertToCPP_ImVec4(col),size,flags,out_clicked,out_hovered,out_held);
}
CIMGUI_API bool ImPlot_DragLineX(int id,double* x,const ImVec4_c col,float thickness,ImPlotDragToolFlags flags,bool* out_clicked,bool* out_hovered,bool* out_held)
{
    return ImPlot::DragLineX(id,x,ConvertToCPP_ImVec4(col),thickness,flags,out_clicked,out_hovered,out_held);
}
CIMGUI_API bool ImPlot_DragLineY(int id,double* y,const ImVec4_c col,float thickness,ImPlotDragToolFlags flags,bool* out_clicked,bool* out_hovered,bool* out_held)
{
    return ImPlot::DragLineY(id,y,ConvertToCPP_ImVec4(col),thickness,flags,out_clicked,out_hovered,out_held);
}
CIMGUI_API bool ImPlot_DragRect(int id,double* x1,double* y1,double* x2,double* y2,const ImVec4_c col,ImPlotDragToolFlags flags,bool* out_clicked,bool* out_hovered,bool* out_held)
{
    return ImPlot::DragRect(id,x1,y1,x2,y2,ConvertToCPP_ImVec4(col),flags,out_clicked,out_hovered,out_held);
}
CIMGUI_API void ImPlot_Annotation_Bool(double x,double y,const ImVec4_c col,const ImVec2_c pix_offset,bool clamp,bool round)
{
    return ImPlot::Annotation(x,y,ConvertToCPP_ImVec4(col),ConvertToCPP_ImVec2(pix_offset),clamp,round);
}
CIMGUI_API void ImPlot_Annotation_Str(double x,double y,const ImVec4_c col,const ImVec2_c pix_offset,bool clamp,const char* fmt,...)
{
    va_list args;
    va_start(args, fmt);
    ImPlot::AnnotationV(x,y,ConvertToCPP_ImVec4(col),ConvertToCPP_ImVec2(pix_offset),clamp,fmt,args);
    va_end(args);
}
#ifdef CIMGUI_VARGS0
CIMGUI_API void ImPlot_Annotation_Str0(double x,double y,const ImVec4_c col,const ImVec2_c pix_offset,bool clamp,const char* fmt)
{
    return ImPlot_Annotation_Str(x,y,col,pix_offset,clamp,fmt);
}
#endif
CIMGUI_API void ImPlot_AnnotationV(double x,double y,const ImVec4_c col,const ImVec2_c pix_offset,bool clamp,const char* fmt,va_list args)
{
    return ImPlot::AnnotationV(x,y,ConvertToCPP_ImVec4(col),ConvertToCPP_ImVec2(pix_offset),clamp,fmt,args);
}
CIMGUI_API void ImPlot_TagX_Bool(double x,const ImVec4_c col,bool round)
{
    return ImPlot::TagX(x,ConvertToCPP_ImVec4(col),round);
}
CIMGUI_API void ImPlot_TagX_Str(double x,const ImVec4_c col,const char* fmt,...)
{
    va_list args;
    va_start(args, fmt);
    ImPlot::TagXV(x,ConvertToCPP_ImVec4(col),fmt,args);
    va_end(args);
}
#ifdef CIMGUI_VARGS0
CIMGUI_API void ImPlot_TagX_Str0(double x,const ImVec4_c col,const char* fmt)
{
    return ImPlot_TagX_Str(x,col,fmt);
}
#endif
CIMGUI_API void ImPlot_TagXV(double x,const ImVec4_c col,const char* fmt,va_list args)
{
    return ImPlot::TagXV(x,ConvertToCPP_ImVec4(col),fmt,args);
}
CIMGUI_API void ImPlot_TagY_Bool(double y,const ImVec4_c col,bool round)
{
    return ImPlot::TagY(y,ConvertToCPP_ImVec4(col),round);
}
CIMGUI_API void ImPlot_TagY_Str(double y,const ImVec4_c col,const char* fmt,...)
{
    va_list args;
    va_start(args, fmt);
    ImPlot::TagYV(y,ConvertToCPP_ImVec4(col),fmt,args);
    va_end(args);
}
#ifdef CIMGUI_VARGS0
CIMGUI_API void ImPlot_TagY_Str0(double y,const ImVec4_c col,const char* fmt)
{
    return ImPlot_TagY_Str(y,col,fmt);
}
#endif
CIMGUI_API void ImPlot_TagYV(double y,const ImVec4_c col,const char* fmt,va_list args)
{
    return ImPlot::TagYV(y,ConvertToCPP_ImVec4(col),fmt,args);
}
CIMGUI_API void ImPlot_SetAxis(ImAxis axis)
{
    return ImPlot::SetAxis(axis);
}
CIMGUI_API void ImPlot_SetAxes(ImAxis x_axis,ImAxis y_axis)
{
    return ImPlot::SetAxes(x_axis,y_axis);
}
CIMGUI_API ImPlotPoint_c ImPlot_PixelsToPlot_Vec2(const ImVec2_c pix,ImAxis x_axis,ImAxis y_axis)
{
    return ConvertFromCPP_ImPlotPoint(ImPlot::PixelsToPlot(ConvertToCPP_ImVec2(pix),x_axis,y_axis));
}
CIMGUI_API ImPlotPoint_c ImPlot_PixelsToPlot_Float(float x,float y,ImAxis x_axis,ImAxis y_axis)
{
    return ConvertFromCPP_ImPlotPoint(ImPlot::PixelsToPlot(x,y,x_axis,y_axis));
}
CIMGUI_API ImVec2_c ImPlot_PlotToPixels_PlotPoInt(const ImPlotPoint_c plt,ImAxis x_axis,ImAxis y_axis)
{
    return ConvertFromCPP_ImVec2(ImPlot::PlotToPixels(ConvertToCPP_ImPlotPoint(plt),x_axis,y_axis));
}
CIMGUI_API ImVec2_c ImPlot_PlotToPixels_double(double x,double y,ImAxis x_axis,ImAxis y_axis)
{
    return ConvertFromCPP_ImVec2(ImPlot::PlotToPixels(x,y,x_axis,y_axis));
}
CIMGUI_API ImVec2_c ImPlot_GetPlotPos()
{
    return ConvertFromCPP_ImVec2(ImPlot::GetPlotPos());
}
CIMGUI_API ImVec2_c ImPlot_GetPlotSize()
{
    return ConvertFromCPP_ImVec2(ImPlot::GetPlotSize());
}
CIMGUI_API ImPlotPoint_c ImPlot_GetPlotMousePos(ImAxis x_axis,ImAxis y_axis)
{
    return ConvertFromCPP_ImPlotPoint(ImPlot::GetPlotMousePos(x_axis,y_axis));
}
CIMGUI_API ImPlotRect_c ImPlot_GetPlotLimits(ImAxis x_axis,ImAxis y_axis)
{
    return ConvertFromCPP_ImPlotRect(ImPlot::GetPlotLimits(x_axis,y_axis));
}
CIMGUI_API bool ImPlot_IsPlotHovered()
{
    return ImPlot::IsPlotHovered();
}
CIMGUI_API bool ImPlot_IsAxisHovered(ImAxis axis)
{
    return ImPlot::IsAxisHovered(axis);
}
CIMGUI_API bool ImPlot_IsSubplotsHovered()
{
    return ImPlot::IsSubplotsHovered();
}
CIMGUI_API bool ImPlot_IsPlotSelected()
{
    return ImPlot::IsPlotSelected();
}
CIMGUI_API ImPlotRect_c ImPlot_GetPlotSelection(ImAxis x_axis,ImAxis y_axis)
{
    return ConvertFromCPP_ImPlotRect(ImPlot::GetPlotSelection(x_axis,y_axis));
}
CIMGUI_API void ImPlot_CancelPlotSelection()
{
    return ImPlot::CancelPlotSelection();
}
CIMGUI_API void ImPlot_HideNextItem(bool hidden,ImPlotCond cond)
{
    return ImPlot::HideNextItem(hidden,cond);
}
CIMGUI_API bool ImPlot_BeginAlignedPlots(const char* group_id,bool vertical)
{
    return ImPlot::BeginAlignedPlots(group_id,vertical);
}
CIMGUI_API void ImPlot_EndAlignedPlots()
{
    return ImPlot::EndAlignedPlots();
}
CIMGUI_API bool ImPlot_BeginLegendPopup(const char* label_id,ImGuiMouseButton mouse_button)
{
    return ImPlot::BeginLegendPopup(label_id,mouse_button);
}
CIMGUI_API void ImPlot_EndLegendPopup()
{
    return ImPlot::EndLegendPopup();
}
CIMGUI_API bool ImPlot_IsLegendEntryHovered(const char* label_id)
{
    return ImPlot::IsLegendEntryHovered(label_id);
}
CIMGUI_API bool ImPlot_BeginDragDropTargetPlot()
{
    return ImPlot::BeginDragDropTargetPlot();
}
CIMGUI_API bool ImPlot_BeginDragDropTargetAxis(ImAxis axis)
{
    return ImPlot::BeginDragDropTargetAxis(axis);
}
CIMGUI_API bool ImPlot_BeginDragDropTargetLegend()
{
    return ImPlot::BeginDragDropTargetLegend();
}
CIMGUI_API void ImPlot_EndDragDropTarget()
{
    return ImPlot::EndDragDropTarget();
}
CIMGUI_API bool ImPlot_BeginDragDropSourcePlot(ImGuiDragDropFlags flags)
{
    return ImPlot::BeginDragDropSourcePlot(flags);
}
CIMGUI_API bool ImPlot_BeginDragDropSourceAxis(ImAxis axis,ImGuiDragDropFlags flags)
{
    return ImPlot::BeginDragDropSourceAxis(axis,flags);
}
CIMGUI_API bool ImPlot_BeginDragDropSourceItem(const char* label_id,ImGuiDragDropFlags flags)
{
    return ImPlot::BeginDragDropSourceItem(label_id,flags);
}
CIMGUI_API void ImPlot_EndDragDropSource()
{
    return ImPlot::EndDragDropSource();
}
CIMGUI_API ImPlotStyle* ImPlot_GetStyle()
{
    return &ImPlot::GetStyle();
}
CIMGUI_API void ImPlot_StyleColorsAuto(ImPlotStyle* dst)
{
    return ImPlot::StyleColorsAuto(dst);
}
CIMGUI_API void ImPlot_StyleColorsClassic(ImPlotStyle* dst)
{
    return ImPlot::StyleColorsClassic(dst);
}
CIMGUI_API void ImPlot_StyleColorsDark(ImPlotStyle* dst)
{
    return ImPlot::StyleColorsDark(dst);
}
CIMGUI_API void ImPlot_StyleColorsLight(ImPlotStyle* dst)
{
    return ImPlot::StyleColorsLight(dst);
}
CIMGUI_API void ImPlot_PushStyleColor_U32(ImPlotCol idx,ImU32 col)
{
    return ImPlot::PushStyleColor(idx,col);
}
CIMGUI_API void ImPlot_PushStyleColor_Vec4(ImPlotCol idx,const ImVec4_c col)
{
    return ImPlot::PushStyleColor(idx,ConvertToCPP_ImVec4(col));
}
CIMGUI_API void ImPlot_PopStyleColor(int count)
{
    return ImPlot::PopStyleColor(count);
}
CIMGUI_API void ImPlot_PushStyleVar_Float(ImPlotStyleVar idx,float val)
{
    return ImPlot::PushStyleVar(idx,val);
}
CIMGUI_API void ImPlot_PushStyleVar_Int(ImPlotStyleVar idx,int val)
{
    return ImPlot::PushStyleVar(idx,val);
}
CIMGUI_API void ImPlot_PushStyleVar_Vec2(ImPlotStyleVar idx,const ImVec2_c val)
{
    return ImPlot::PushStyleVar(idx,ConvertToCPP_ImVec2(val));
}
CIMGUI_API void ImPlot_PopStyleVar(int count)
{
    return ImPlot::PopStyleVar(count);
}
CIMGUI_API void ImPlot_SetNextLineStyle(const ImVec4_c col,float weight)
{
    return ImPlot::SetNextLineStyle(ConvertToCPP_ImVec4(col),weight);
}
CIMGUI_API void ImPlot_SetNextFillStyle(const ImVec4_c col,float alpha_mod)
{
    return ImPlot::SetNextFillStyle(ConvertToCPP_ImVec4(col),alpha_mod);
}
CIMGUI_API void ImPlot_SetNextMarkerStyle(ImPlotMarker marker,float size,const ImVec4_c fill,float weight,const ImVec4_c outline)
{
    return ImPlot::SetNextMarkerStyle(marker,size,ConvertToCPP_ImVec4(fill),weight,ConvertToCPP_ImVec4(outline));
}
CIMGUI_API void ImPlot_SetNextErrorBarStyle(const ImVec4_c col,float size,float weight)
{
    return ImPlot::SetNextErrorBarStyle(ConvertToCPP_ImVec4(col),size,weight);
}
CIMGUI_API ImVec4_c ImPlot_GetLastItemColor()
{
    return ConvertFromCPP_ImVec4(ImPlot::GetLastItemColor());
}
CIMGUI_API const char* ImPlot_GetStyleColorName(ImPlotCol idx)
{
    return ImPlot::GetStyleColorName(idx);
}
CIMGUI_API const char* ImPlot_GetMarkerName(ImPlotMarker idx)
{
    return ImPlot::GetMarkerName(idx);
}
CIMGUI_API ImPlotColormap ImPlot_AddColormap_Vec4Ptr(const char* name,const ImVec4* cols,int size,bool qual)
{
    return ImPlot::AddColormap(name,cols,size,qual);
}
CIMGUI_API ImPlotColormap ImPlot_AddColormap_U32Ptr(const char* name,const ImU32* cols,int size,bool qual)
{
    return ImPlot::AddColormap(name,cols,size,qual);
}
CIMGUI_API int ImPlot_GetColormapCount()
{
    return ImPlot::GetColormapCount();
}
CIMGUI_API const char* ImPlot_GetColormapName(ImPlotColormap cmap)
{
    return ImPlot::GetColormapName(cmap);
}
CIMGUI_API ImPlotColormap ImPlot_GetColormapIndex(const char* name)
{
    return ImPlot::GetColormapIndex(name);
}
CIMGUI_API void ImPlot_PushColormap_PlotColormap(ImPlotColormap cmap)
{
    return ImPlot::PushColormap(cmap);
}
CIMGUI_API void ImPlot_PushColormap_Str(const char* name)
{
    return ImPlot::PushColormap(name);
}
CIMGUI_API void ImPlot_PopColormap(int count)
{
    return ImPlot::PopColormap(count);
}
CIMGUI_API ImVec4_c ImPlot_NextColormapColor()
{
    return ConvertFromCPP_ImVec4(ImPlot::NextColormapColor());
}
CIMGUI_API int ImPlot_GetColormapSize(ImPlotColormap cmap)
{
    return ImPlot::GetColormapSize(cmap);
}
CIMGUI_API ImVec4_c ImPlot_GetColormapColor(int idx,ImPlotColormap cmap)
{
    return ConvertFromCPP_ImVec4(ImPlot::GetColormapColor(idx,cmap));
}
CIMGUI_API ImVec4_c ImPlot_SampleColormap(float t,ImPlotColormap cmap)
{
    return ConvertFromCPP_ImVec4(ImPlot::SampleColormap(t,cmap));
}
CIMGUI_API void ImPlot_ColormapScale(const char* label,double scale_min,double scale_max,const ImVec2_c size,const char* format,ImPlotColormapScaleFlags flags,ImPlotColormap cmap)
{
    return ImPlot::ColormapScale(label,scale_min,scale_max,ConvertToCPP_ImVec2(size),format,flags,cmap);
}
CIMGUI_API bool ImPlot_ColormapSlider(const char* label,float* t,ImVec4* out,const char* format,ImPlotColormap cmap)
{
    return ImPlot::ColormapSlider(label,t,out,format,cmap);
}
CIMGUI_API bool ImPlot_ColormapButton(const char* label,const ImVec2_c size,ImPlotColormap cmap)
{
    return ImPlot::ColormapButton(label,ConvertToCPP_ImVec2(size),cmap);
}
CIMGUI_API void ImPlot_BustColorCache(const char* plot_title_id)
{
    return ImPlot::BustColorCache(plot_title_id);
}
CIMGUI_API ImPlotInputMap* ImPlot_GetInputMap()
{
    return &ImPlot::GetInputMap();
}
CIMGUI_API void ImPlot_MapInputDefault(ImPlotInputMap* dst)
{
    return ImPlot::MapInputDefault(dst);
}
CIMGUI_API void ImPlot_MapInputReverse(ImPlotInputMap* dst)
{
    return ImPlot::MapInputReverse(dst);
}
CIMGUI_API void ImPlot_ItemIcon_Vec4(const ImVec4_c col)
{
    return ImPlot::ItemIcon(ConvertToCPP_ImVec4(col));
}
CIMGUI_API void ImPlot_ItemIcon_U32(ImU32 col)
{
    return ImPlot::ItemIcon(col);
}
CIMGUI_API void ImPlot_ColormapIcon(ImPlotColormap cmap)
{
    return ImPlot::ColormapIcon(cmap);
}
CIMGUI_API ImDrawList* ImPlot_GetPlotDrawList()
{
    return ImPlot::GetPlotDrawList();
}
CIMGUI_API void ImPlot_PushPlotClipRect(float expand)
{
    return ImPlot::PushPlotClipRect(expand);
}
CIMGUI_API void ImPlot_PopPlotClipRect()
{
    return ImPlot::PopPlotClipRect();
}
CIMGUI_API bool ImPlot_ShowStyleSelector(const char* label)
{
    return ImPlot::ShowStyleSelector(label);
}
CIMGUI_API bool ImPlot_ShowColormapSelector(const char* label)
{
    return ImPlot::ShowColormapSelector(label);
}
CIMGUI_API bool ImPlot_ShowInputMapSelector(const char* label)
{
    return ImPlot::ShowInputMapSelector(label);
}
CIMGUI_API void ImPlot_ShowStyleEditor(ImPlotStyle* ref)
{
    return ImPlot::ShowStyleEditor(ref);
}
CIMGUI_API void ImPlot_ShowUserGuide()
{
    return ImPlot::ShowUserGuide();
}
CIMGUI_API void ImPlot_ShowMetricsWindow(bool* p_popen)
{
    return ImPlot::ShowMetricsWindow(p_popen);
}
CIMGUI_API void ImPlot_ShowDemoWindow(bool* p_open)
{
    return ImPlot::ShowDemoWindow(p_open);
}
CIMGUI_API float ImPlot_ImLog10_Float(float x)
{
    return ImLog10(x);
}
CIMGUI_API double ImPlot_ImLog10_double(double x)
{
    return ImLog10(x);
}
CIMGUI_API float ImPlot_ImSinh_Float(float x)
{
    return ImSinh(x);
}
CIMGUI_API double ImPlot_ImSinh_double(double x)
{
    return ImSinh(x);
}
CIMGUI_API float ImPlot_ImAsinh_Float(float x)
{
    return ImAsinh(x);
}
CIMGUI_API double ImPlot_ImAsinh_double(double x)
{
    return ImAsinh(x);
}
CIMGUI_API float ImPlot_ImRemap_Float(float x,float x0,float x1,float y0,float y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API double ImPlot_ImRemap_double(double x,double x0,double x1,double y0,double y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImS8 ImPlot_ImRemap_S8(ImS8 x,ImS8 x0,ImS8 x1,ImS8 y0,ImS8 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImU8 ImPlot_ImRemap_U8(ImU8 x,ImU8 x0,ImU8 x1,ImU8 y0,ImU8 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImS16 ImPlot_ImRemap_S16(ImS16 x,ImS16 x0,ImS16 x1,ImS16 y0,ImS16 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImU16 ImPlot_ImRemap_U16(ImU16 x,ImU16 x0,ImU16 x1,ImU16 y0,ImU16 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImS32 ImPlot_ImRemap_S32(ImS32 x,ImS32 x0,ImS32 x1,ImS32 y0,ImS32 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImU32 ImPlot_ImRemap_U32(ImU32 x,ImU32 x0,ImU32 x1,ImU32 y0,ImU32 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImS64 ImPlot_ImRemap_S64(ImS64 x,ImS64 x0,ImS64 x1,ImS64 y0,ImS64 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API ImU64 ImPlot_ImRemap_U64(ImU64 x,ImU64 x0,ImU64 x1,ImU64 y0,ImU64 y1)
{
    return ImRemap(x,x0,x1,y0,y1);
}
CIMGUI_API float ImPlot_ImRemap01_Float(float x,float x0,float x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API double ImPlot_ImRemap01_double(double x,double x0,double x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImS8 ImPlot_ImRemap01_S8(ImS8 x,ImS8 x0,ImS8 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImU8 ImPlot_ImRemap01_U8(ImU8 x,ImU8 x0,ImU8 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImS16 ImPlot_ImRemap01_S16(ImS16 x,ImS16 x0,ImS16 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImU16 ImPlot_ImRemap01_U16(ImU16 x,ImU16 x0,ImU16 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImS32 ImPlot_ImRemap01_S32(ImS32 x,ImS32 x0,ImS32 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImU32 ImPlot_ImRemap01_U32(ImU32 x,ImU32 x0,ImU32 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImS64 ImPlot_ImRemap01_S64(ImS64 x,ImS64 x0,ImS64 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API ImU64 ImPlot_ImRemap01_U64(ImU64 x,ImU64 x0,ImU64 x1)
{
    return ImRemap01(x,x0,x1);
}
CIMGUI_API int ImPlot_ImPosMod(int l,int r)
{
    return ImPosMod(l,r);
}
CIMGUI_API bool ImPlot_ImNan(double val)
{
    return ImNan(val);
}
CIMGUI_API bool ImPlot_ImNanOrInf(double val)
{
    return ImNanOrInf(val);
}
CIMGUI_API double ImPlot_ImConstrainNan(double val)
{
    return ImConstrainNan(val);
}
CIMGUI_API double ImPlot_ImConstrainInf(double val)
{
    return ImConstrainInf(val);
}
CIMGUI_API double ImPlot_ImConstrainLog(double val)
{
    return ImConstrainLog(val);
}
CIMGUI_API double ImPlot_ImConstrainTime(double val)
{
    return ImConstrainTime(val);
}
CIMGUI_API bool ImPlot_ImAlmostEqual(double v1,double v2,int ulp)
{
    return ImAlmostEqual(v1,v2,ulp);
}
CIMGUI_API float ImPlot_ImMinArray_FloatPtr(const float* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API double ImPlot_ImMinArray_doublePtr(const double* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImS8 ImPlot_ImMinArray_S8Ptr(const ImS8* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImU8 ImPlot_ImMinArray_U8Ptr(const ImU8* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImS16 ImPlot_ImMinArray_S16Ptr(const ImS16* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImU16 ImPlot_ImMinArray_U16Ptr(const ImU16* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImS32 ImPlot_ImMinArray_S32Ptr(const ImS32* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImU32 ImPlot_ImMinArray_U32Ptr(const ImU32* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImS64 ImPlot_ImMinArray_S64Ptr(const ImS64* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API ImU64 ImPlot_ImMinArray_U64Ptr(const ImU64* values,int count)
{
    return ImMinArray(values,count);
}
CIMGUI_API float ImPlot_ImMaxArray_FloatPtr(const float* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API double ImPlot_ImMaxArray_doublePtr(const double* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImS8 ImPlot_ImMaxArray_S8Ptr(const ImS8* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImU8 ImPlot_ImMaxArray_U8Ptr(const ImU8* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImS16 ImPlot_ImMaxArray_S16Ptr(const ImS16* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImU16 ImPlot_ImMaxArray_U16Ptr(const ImU16* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImS32 ImPlot_ImMaxArray_S32Ptr(const ImS32* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImU32 ImPlot_ImMaxArray_U32Ptr(const ImU32* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImS64 ImPlot_ImMaxArray_S64Ptr(const ImS64* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API ImU64 ImPlot_ImMaxArray_U64Ptr(const ImU64* values,int count)
{
    return ImMaxArray(values,count);
}
CIMGUI_API void ImPlot_ImMinMaxArray_FloatPtr(const float* values,int count,float* min_out,float* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_doublePtr(const double* values,int count,double* min_out,double* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_S8Ptr(const ImS8* values,int count,ImS8* min_out,ImS8* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_U8Ptr(const ImU8* values,int count,ImU8* min_out,ImU8* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_S16Ptr(const ImS16* values,int count,ImS16* min_out,ImS16* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_U16Ptr(const ImU16* values,int count,ImU16* min_out,ImU16* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_S32Ptr(const ImS32* values,int count,ImS32* min_out,ImS32* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_U32Ptr(const ImU32* values,int count,ImU32* min_out,ImU32* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_S64Ptr(const ImS64* values,int count,ImS64* min_out,ImS64* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API void ImPlot_ImMinMaxArray_U64Ptr(const ImU64* values,int count,ImU64* min_out,ImU64* max_out)
{
    return ImMinMaxArray(values,count,min_out,max_out);
}
CIMGUI_API float ImPlot_ImSum_FloatPtr(const float* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API double ImPlot_ImSum_doublePtr(const double* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImS8 ImPlot_ImSum_S8Ptr(const ImS8* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImU8 ImPlot_ImSum_U8Ptr(const ImU8* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImS16 ImPlot_ImSum_S16Ptr(const ImS16* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImU16 ImPlot_ImSum_U16Ptr(const ImU16* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImS32 ImPlot_ImSum_S32Ptr(const ImS32* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImU32 ImPlot_ImSum_U32Ptr(const ImU32* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImS64 ImPlot_ImSum_S64Ptr(const ImS64* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API ImU64 ImPlot_ImSum_U64Ptr(const ImU64* values,int count)
{
    return ImSum(values,count);
}
CIMGUI_API double ImPlot_ImMean_FloatPtr(const float* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_doublePtr(const double* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_S8Ptr(const ImS8* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_U8Ptr(const ImU8* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_S16Ptr(const ImS16* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_U16Ptr(const ImU16* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_S32Ptr(const ImS32* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_U32Ptr(const ImU32* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_S64Ptr(const ImS64* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImMean_U64Ptr(const ImU64* values,int count)
{
    return ImMean(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_FloatPtr(const float* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_doublePtr(const double* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_S8Ptr(const ImS8* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_U8Ptr(const ImU8* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_S16Ptr(const ImS16* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_U16Ptr(const ImU16* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_S32Ptr(const ImS32* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_U32Ptr(const ImU32* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_S64Ptr(const ImS64* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API double ImPlot_ImStdDev_U64Ptr(const ImU64* values,int count)
{
    return ImStdDev(values,count);
}
CIMGUI_API ImU32 ImPlot_ImMixU32(ImU32 a,ImU32 b,ImU32 s)
{
    return ImMixU32(a,b,s);
}
CIMGUI_API ImU32 ImPlot_ImLerpU32(const ImU32* colors,int size,float t)
{
    return ImLerpU32(colors,size,t);
}
CIMGUI_API ImU32 ImPlot_ImAlphaU32(ImU32 col,float alpha)
{
    return ImAlphaU32(col,alpha);
}
CIMGUI_API bool ImPlot_ImOverlaps_Float(float min_a,float max_a,float min_b,float max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_double(double min_a,double max_a,double min_b,double max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_S8(ImS8 min_a,ImS8 max_a,ImS8 min_b,ImS8 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_U8(ImU8 min_a,ImU8 max_a,ImU8 min_b,ImU8 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_S16(ImS16 min_a,ImS16 max_a,ImS16 min_b,ImS16 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_U16(ImU16 min_a,ImU16 max_a,ImU16 min_b,ImU16 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_S32(ImS32 min_a,ImS32 max_a,ImS32 min_b,ImS32 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_U32(ImU32 min_a,ImU32 max_a,ImU32 min_b,ImU32 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_S64(ImS64 min_a,ImS64 max_a,ImS64 min_b,ImS64 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API bool ImPlot_ImOverlaps_U64(ImU64 min_a,ImU64 max_a,ImU64 min_b,ImU64 max_b)
{
    return ImOverlaps(min_a,max_a,min_b,max_b);
}
CIMGUI_API ImPlotDateTimeSpec* ImPlotDateTimeSpec_ImPlotDateTimeSpec_Nil(void)
{
    return IM_NEW(ImPlotDateTimeSpec)();
}
CIMGUI_API void ImPlotDateTimeSpec_destroy(ImPlotDateTimeSpec* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotDateTimeSpec* ImPlotDateTimeSpec_ImPlotDateTimeSpec_PlotDateFmt(ImPlotDateFmt date_fmt,ImPlotTimeFmt time_fmt,bool use_24_hr_clk,bool use_iso_8601)
{
    return IM_NEW(ImPlotDateTimeSpec)(date_fmt,time_fmt,use_24_hr_clk,use_iso_8601);
}
CIMGUI_API ImPlotTime* ImPlotTime_ImPlotTime_Nil(void)
{
    return IM_NEW(ImPlotTime)();
}
CIMGUI_API void ImPlotTime_destroy(ImPlotTime* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotTime* ImPlotTime_ImPlotTime_time_t(time_t s,int us)
{
    return IM_NEW(ImPlotTime)(s,us);
}
CIMGUI_API void ImPlotTime_RollOver(ImPlotTime* self)
{
    return self->RollOver();
}
CIMGUI_API double ImPlotTime_ToDouble(ImPlotTime* self)
{
    return self->ToDouble();
}
CIMGUI_API ImPlotTime_c ImPlotTime_FromDouble(double t)
{
    return ConvertFromCPP_ImPlotTime(ImPlotTime::FromDouble(t));
}
CIMGUI_API ImPlotColormapData* ImPlotColormapData_ImPlotColormapData(void)
{
    return IM_NEW(ImPlotColormapData)();
}
CIMGUI_API void ImPlotColormapData_destroy(ImPlotColormapData* self)
{
    IM_DELETE(self);
}
CIMGUI_API int ImPlotColormapData_Append(ImPlotColormapData* self,const char* name,const ImU32* keys,int count,bool qual)
{
    return self->Append(name,keys,count,qual);
}
CIMGUI_API void ImPlotColormapData__AppendTable(ImPlotColormapData* self,ImPlotColormap cmap)
{
    return self->_AppendTable(cmap);
}
CIMGUI_API void ImPlotColormapData_RebuildTables(ImPlotColormapData* self)
{
    return self->RebuildTables();
}
CIMGUI_API bool ImPlotColormapData_IsQual(ImPlotColormapData* self,ImPlotColormap cmap)
{
    return self->IsQual(cmap);
}
CIMGUI_API const char* ImPlotColormapData_GetName(ImPlotColormapData* self,ImPlotColormap cmap)
{
    return self->GetName(cmap);
}
CIMGUI_API ImPlotColormap ImPlotColormapData_GetIndex(ImPlotColormapData* self,const char* name)
{
    return self->GetIndex(name);
}
CIMGUI_API const ImU32* ImPlotColormapData_GetKeys(ImPlotColormapData* self,ImPlotColormap cmap)
{
    return self->GetKeys(cmap);
}
CIMGUI_API int ImPlotColormapData_GetKeyCount(ImPlotColormapData* self,ImPlotColormap cmap)
{
    return self->GetKeyCount(cmap);
}
CIMGUI_API ImU32 ImPlotColormapData_GetKeyColor(ImPlotColormapData* self,ImPlotColormap cmap,int idx)
{
    return self->GetKeyColor(cmap,idx);
}
CIMGUI_API void ImPlotColormapData_SetKeyColor(ImPlotColormapData* self,ImPlotColormap cmap,int idx,ImU32 value)
{
    return self->SetKeyColor(cmap,idx,value);
}
CIMGUI_API const ImU32* ImPlotColormapData_GetTable(ImPlotColormapData* self,ImPlotColormap cmap)
{
    return self->GetTable(cmap);
}
CIMGUI_API int ImPlotColormapData_GetTableSize(ImPlotColormapData* self,ImPlotColormap cmap)
{
    return self->GetTableSize(cmap);
}
CIMGUI_API ImU32 ImPlotColormapData_GetTableColor(ImPlotColormapData* self,ImPlotColormap cmap,int idx)
{
    return self->GetTableColor(cmap,idx);
}
CIMGUI_API ImU32 ImPlotColormapData_LerpTable(ImPlotColormapData* self,ImPlotColormap cmap,float t)
{
    return self->LerpTable(cmap,t);
}
CIMGUI_API ImPlotPointError* ImPlotPointError_ImPlotPointError_Nil(void)
{
    return IM_NEW(ImPlotPointError)();
}
CIMGUI_API void ImPlotPointError_destroy(ImPlotPointError* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotPointError* ImPlotPointError_ImPlotPointError_double(double x,double y,double neg,double pos)
{
    return IM_NEW(ImPlotPointError)(x,y,neg,pos);
}
CIMGUI_API ImPlotAnnotation* ImPlotAnnotation_ImPlotAnnotation(void)
{
    return IM_NEW(ImPlotAnnotation)();
}
CIMGUI_API void ImPlotAnnotation_destroy(ImPlotAnnotation* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotAnnotationCollection* ImPlotAnnotationCollection_ImPlotAnnotationCollection(void)
{
    return IM_NEW(ImPlotAnnotationCollection)();
}
CIMGUI_API void ImPlotAnnotationCollection_destroy(ImPlotAnnotationCollection* self)
{
    IM_DELETE(self);
}
CIMGUI_API void ImPlotAnnotationCollection_AppendV(ImPlotAnnotationCollection* self,const ImVec2_c pos,const ImVec2_c off,ImU32 bg,ImU32 fg,bool clamp,const char* fmt,va_list args)
{
    return self->AppendV(ConvertToCPP_ImVec2(pos),ConvertToCPP_ImVec2(off),bg,fg,clamp,fmt,args);
}
CIMGUI_API void ImPlotAnnotationCollection_Append(ImPlotAnnotationCollection* self,const ImVec2_c pos,const ImVec2_c off,ImU32 bg,ImU32 fg,bool clamp,const char* fmt,...)
{
    va_list args;
    va_start(args, fmt);
    self->AppendV(ConvertToCPP_ImVec2(pos),ConvertToCPP_ImVec2(off),bg,fg,clamp,fmt,args);
    va_end(args);
}
CIMGUI_API const char* ImPlotAnnotationCollection_GetText(ImPlotAnnotationCollection* self,int idx)
{
    return self->GetText(idx);
}
CIMGUI_API void ImPlotAnnotationCollection_Reset(ImPlotAnnotationCollection* self)
{
    return self->Reset();
}
CIMGUI_API ImPlotTag* ImPlotTag_ImPlotTag(void)
{
    return IM_NEW(ImPlotTag)();
}
CIMGUI_API void ImPlotTag_destroy(ImPlotTag* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotTagCollection* ImPlotTagCollection_ImPlotTagCollection(void)
{
    return IM_NEW(ImPlotTagCollection)();
}
CIMGUI_API void ImPlotTagCollection_destroy(ImPlotTagCollection* self)
{
    IM_DELETE(self);
}
CIMGUI_API void ImPlotTagCollection_AppendV(ImPlotTagCollection* self,ImAxis axis,double value,ImU32 bg,ImU32 fg,const char* fmt,va_list args)
{
    return self->AppendV(axis,value,bg,fg,fmt,args);
}
CIMGUI_API void ImPlotTagCollection_Append(ImPlotTagCollection* self,ImAxis axis,double value,ImU32 bg,ImU32 fg,const char* fmt,...)
{
    va_list args;
    va_start(args, fmt);
    self->AppendV(axis,value,bg,fg,fmt,args);
    va_end(args);
}
CIMGUI_API const char* ImPlotTagCollection_GetText(ImPlotTagCollection* self,int idx)
{
    return self->GetText(idx);
}
CIMGUI_API void ImPlotTagCollection_Reset(ImPlotTagCollection* self)
{
    return self->Reset();
}
CIMGUI_API ImPlotTick* ImPlotTick_ImPlotTick_Nil(void)
{
    return IM_NEW(ImPlotTick)();
}
CIMGUI_API void ImPlotTick_destroy(ImPlotTick* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotTick* ImPlotTick_ImPlotTick_double(double value,bool major,int level,bool show_label)
{
    return IM_NEW(ImPlotTick)(value,major,level,show_label);
}
CIMGUI_API ImPlotTicker* ImPlotTicker_ImPlotTicker(void)
{
    return IM_NEW(ImPlotTicker)();
}
CIMGUI_API void ImPlotTicker_destroy(ImPlotTicker* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotTick* ImPlotTicker_AddTick_doubleStr(ImPlotTicker* self,double value,bool major,int level,bool show_label,const char* label)
{
    return &self->AddTick(value,major,level,show_label,label);
}
CIMGUI_API ImPlotTick* ImPlotTicker_AddTick_doublePlotFormatter(ImPlotTicker* self,double value,bool major,int level,bool show_label,ImPlotFormatter formatter,void* data)
{
    return &self->AddTick(value,major,level,show_label,formatter,data);
}
CIMGUI_API ImPlotTick* ImPlotTicker_AddTick_PlotTick(ImPlotTicker* self,ImPlotTick_c tick)
{
    return &self->AddTick(ConvertToCPP_ImPlotTick(tick));
}
CIMGUI_API const char* ImPlotTicker_GetText_Int(ImPlotTicker* self,int idx)
{
    return self->GetText(idx);
}
CIMGUI_API const char* ImPlotTicker_GetText_PlotTick(ImPlotTicker* self,const ImPlotTick_c tick)
{
    return self->GetText(ConvertToCPP_ImPlotTick(tick));
}
CIMGUI_API void ImPlotTicker_OverrideSizeLate(ImPlotTicker* self,const ImVec2_c size)
{
    return self->OverrideSizeLate(ConvertToCPP_ImVec2(size));
}
CIMGUI_API void ImPlotTicker_Reset(ImPlotTicker* self)
{
    return self->Reset();
}
CIMGUI_API int ImPlotTicker_TickCount(ImPlotTicker* self)
{
    return self->TickCount();
}
CIMGUI_API ImPlotAxis* ImPlotAxis_ImPlotAxis(void)
{
    return IM_NEW(ImPlotAxis)();
}
CIMGUI_API void ImPlotAxis_destroy(ImPlotAxis* self)
{
    IM_DELETE(self);
}
CIMGUI_API void ImPlotAxis_Reset(ImPlotAxis* self)
{
    return self->Reset();
}
CIMGUI_API bool ImPlotAxis_SetMin(ImPlotAxis* self,double _min,bool force)
{
    return self->SetMin(_min,force);
}
CIMGUI_API bool ImPlotAxis_SetMax(ImPlotAxis* self,double _max,bool force)
{
    return self->SetMax(_max,force);
}
CIMGUI_API void ImPlotAxis_SetRange_double(ImPlotAxis* self,double v1,double v2)
{
    return self->SetRange(v1,v2);
}
CIMGUI_API void ImPlotAxis_SetRange_PlotRange(ImPlotAxis* self,const ImPlotRange_c range)
{
    return self->SetRange(ConvertToCPP_ImPlotRange(range));
}
CIMGUI_API void ImPlotAxis_SetAspect(ImPlotAxis* self,double unit_per_pix)
{
    return self->SetAspect(unit_per_pix);
}
CIMGUI_API float ImPlotAxis_PixelSize(ImPlotAxis* self)
{
    return self->PixelSize();
}
CIMGUI_API double ImPlotAxis_GetAspect(ImPlotAxis* self)
{
    return self->GetAspect();
}
CIMGUI_API void ImPlotAxis_Constrain(ImPlotAxis* self)
{
    return self->Constrain();
}
CIMGUI_API void ImPlotAxis_UpdateTransformCache(ImPlotAxis* self)
{
    return self->UpdateTransformCache();
}
CIMGUI_API float ImPlotAxis_PlotToPixels(ImPlotAxis* self,double plt)
{
    return self->PlotToPixels(plt);
}
CIMGUI_API double ImPlotAxis_PixelsToPlot(ImPlotAxis* self,float pix)
{
    return self->PixelsToPlot(pix);
}
CIMGUI_API void ImPlotAxis_ExtendFit(ImPlotAxis* self,double v)
{
    return self->ExtendFit(v);
}
CIMGUI_API void ImPlotAxis_ExtendFitWith(ImPlotAxis* self,ImPlotAxis* alt,double v,double v_alt)
{
    return self->ExtendFitWith(*alt,v,v_alt);
}
CIMGUI_API void ImPlotAxis_ApplyFit(ImPlotAxis* self,float padding)
{
    return self->ApplyFit(padding);
}
CIMGUI_API bool ImPlotAxis_HasLabel(ImPlotAxis* self)
{
    return self->HasLabel();
}
CIMGUI_API bool ImPlotAxis_HasGridLines(ImPlotAxis* self)
{
    return self->HasGridLines();
}
CIMGUI_API bool ImPlotAxis_HasTickLabels(ImPlotAxis* self)
{
    return self->HasTickLabels();
}
CIMGUI_API bool ImPlotAxis_HasTickMarks(ImPlotAxis* self)
{
    return self->HasTickMarks();
}
CIMGUI_API bool ImPlotAxis_WillRender(ImPlotAxis* self)
{
    return self->WillRender();
}
CIMGUI_API bool ImPlotAxis_IsOpposite(ImPlotAxis* self)
{
    return self->IsOpposite();
}
CIMGUI_API bool ImPlotAxis_IsInverted(ImPlotAxis* self)
{
    return self->IsInverted();
}
CIMGUI_API bool ImPlotAxis_IsForeground(ImPlotAxis* self)
{
    return self->IsForeground();
}
CIMGUI_API bool ImPlotAxis_IsAutoFitting(ImPlotAxis* self)
{
    return self->IsAutoFitting();
}
CIMGUI_API bool ImPlotAxis_CanInitFit(ImPlotAxis* self)
{
    return self->CanInitFit();
}
CIMGUI_API bool ImPlotAxis_IsRangeLocked(ImPlotAxis* self)
{
    return self->IsRangeLocked();
}
CIMGUI_API bool ImPlotAxis_IsLockedMin(ImPlotAxis* self)
{
    return self->IsLockedMin();
}
CIMGUI_API bool ImPlotAxis_IsLockedMax(ImPlotAxis* self)
{
    return self->IsLockedMax();
}
CIMGUI_API bool ImPlotAxis_IsLocked(ImPlotAxis* self)
{
    return self->IsLocked();
}
CIMGUI_API bool ImPlotAxis_IsInputLockedMin(ImPlotAxis* self)
{
    return self->IsInputLockedMin();
}
CIMGUI_API bool ImPlotAxis_IsInputLockedMax(ImPlotAxis* self)
{
    return self->IsInputLockedMax();
}
CIMGUI_API bool ImPlotAxis_IsInputLocked(ImPlotAxis* self)
{
    return self->IsInputLocked();
}
CIMGUI_API bool ImPlotAxis_HasMenus(ImPlotAxis* self)
{
    return self->HasMenus();
}
CIMGUI_API bool ImPlotAxis_IsPanLocked(ImPlotAxis* self,bool increasing)
{
    return self->IsPanLocked(increasing);
}
CIMGUI_API void ImPlotAxis_PushLinks(ImPlotAxis* self)
{
    return self->PushLinks();
}
CIMGUI_API void ImPlotAxis_PullLinks(ImPlotAxis* self)
{
    return self->PullLinks();
}
CIMGUI_API ImPlotAlignmentData* ImPlotAlignmentData_ImPlotAlignmentData(void)
{
    return IM_NEW(ImPlotAlignmentData)();
}
CIMGUI_API void ImPlotAlignmentData_destroy(ImPlotAlignmentData* self)
{
    IM_DELETE(self);
}
CIMGUI_API void ImPlotAlignmentData_Begin(ImPlotAlignmentData* self)
{
    return self->Begin();
}
CIMGUI_API void ImPlotAlignmentData_Update(ImPlotAlignmentData* self,float* pad_a,float* pad_b,float* delta_a,float* delta_b)
{
    return self->Update(*pad_a,*pad_b,*delta_a,*delta_b);
}
CIMGUI_API void ImPlotAlignmentData_End(ImPlotAlignmentData* self)
{
    return self->End();
}
CIMGUI_API void ImPlotAlignmentData_Reset(ImPlotAlignmentData* self)
{
    return self->Reset();
}
CIMGUI_API ImPlotItem* ImPlotItem_ImPlotItem(void)
{
    return IM_NEW(ImPlotItem)();
}
CIMGUI_API void ImPlotItem_destroy(ImPlotItem* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotLegend* ImPlotLegend_ImPlotLegend(void)
{
    return IM_NEW(ImPlotLegend)();
}
CIMGUI_API void ImPlotLegend_destroy(ImPlotLegend* self)
{
    IM_DELETE(self);
}
CIMGUI_API void ImPlotLegend_Reset(ImPlotLegend* self)
{
    return self->Reset();
}
CIMGUI_API ImPlotItemGroup* ImPlotItemGroup_ImPlotItemGroup(void)
{
    return IM_NEW(ImPlotItemGroup)();
}
CIMGUI_API void ImPlotItemGroup_destroy(ImPlotItemGroup* self)
{
    IM_DELETE(self);
}
CIMGUI_API int ImPlotItemGroup_GetItemCount(ImPlotItemGroup* self)
{
    return self->GetItemCount();
}
CIMGUI_API ImGuiID ImPlotItemGroup_GetItemID(ImPlotItemGroup* self,const char* label_id)
{
    return self->GetItemID(label_id);
}
CIMGUI_API ImPlotItem* ImPlotItemGroup_GetItem_ID(ImPlotItemGroup* self,ImGuiID id)
{
    return self->GetItem(id);
}
CIMGUI_API ImPlotItem* ImPlotItemGroup_GetItem_Str(ImPlotItemGroup* self,const char* label_id)
{
    return self->GetItem(label_id);
}
CIMGUI_API ImPlotItem* ImPlotItemGroup_GetOrAddItem(ImPlotItemGroup* self,ImGuiID id)
{
    return self->GetOrAddItem(id);
}
CIMGUI_API ImPlotItem* ImPlotItemGroup_GetItemByIndex(ImPlotItemGroup* self,int i)
{
    return self->GetItemByIndex(i);
}
CIMGUI_API int ImPlotItemGroup_GetItemIndex(ImPlotItemGroup* self,ImPlotItem* item)
{
    return self->GetItemIndex(item);
}
CIMGUI_API int ImPlotItemGroup_GetLegendCount(ImPlotItemGroup* self)
{
    return self->GetLegendCount();
}
CIMGUI_API ImPlotItem* ImPlotItemGroup_GetLegendItem(ImPlotItemGroup* self,int i)
{
    return self->GetLegendItem(i);
}
CIMGUI_API const char* ImPlotItemGroup_GetLegendLabel(ImPlotItemGroup* self,int i)
{
    return self->GetLegendLabel(i);
}
CIMGUI_API void ImPlotItemGroup_Reset(ImPlotItemGroup* self)
{
    return self->Reset();
}
CIMGUI_API ImPlotPlot* ImPlotPlot_ImPlotPlot(void)
{
    return IM_NEW(ImPlotPlot)();
}
CIMGUI_API void ImPlotPlot_destroy(ImPlotPlot* self)
{
    IM_DELETE(self);
}
CIMGUI_API bool ImPlotPlot_IsInputLocked(ImPlotPlot* self)
{
    return self->IsInputLocked();
}
CIMGUI_API void ImPlotPlot_ClearTextBuffer(ImPlotPlot* self)
{
    return self->ClearTextBuffer();
}
CIMGUI_API void ImPlotPlot_SetTitle(ImPlotPlot* self,const char* title)
{
    return self->SetTitle(title);
}
CIMGUI_API bool ImPlotPlot_HasTitle(ImPlotPlot* self)
{
    return self->HasTitle();
}
CIMGUI_API const char* ImPlotPlot_GetTitle(ImPlotPlot* self)
{
    return self->GetTitle();
}
CIMGUI_API ImPlotAxis* ImPlotPlot_XAxis_Nil(ImPlotPlot* self,int i)
{
    return &self->XAxis(i);
}
CIMGUI_API const ImPlotAxis* ImPlotPlot_XAxis__const(ImPlotPlot* self,int i)
{
    return &self->XAxis(i);
}
CIMGUI_API ImPlotAxis* ImPlotPlot_YAxis_Nil(ImPlotPlot* self,int i)
{
    return &self->YAxis(i);
}
CIMGUI_API const ImPlotAxis* ImPlotPlot_YAxis__const(ImPlotPlot* self,int i)
{
    return &self->YAxis(i);
}
CIMGUI_API int ImPlotPlot_EnabledAxesX(ImPlotPlot* self)
{
    return self->EnabledAxesX();
}
CIMGUI_API int ImPlotPlot_EnabledAxesY(ImPlotPlot* self)
{
    return self->EnabledAxesY();
}
CIMGUI_API void ImPlotPlot_SetAxisLabel(ImPlotPlot* self,ImPlotAxis* axis,const char* label)
{
    return self->SetAxisLabel(*axis,label);
}
CIMGUI_API const char* ImPlotPlot_GetAxisLabel(ImPlotPlot* self,const ImPlotAxis_c axis)
{
    return self->GetAxisLabel(ConvertToCPP_ImPlotAxis(axis));
}
CIMGUI_API ImPlotSubplot* ImPlotSubplot_ImPlotSubplot(void)
{
    return IM_NEW(ImPlotSubplot)();
}
CIMGUI_API void ImPlotSubplot_destroy(ImPlotSubplot* self)
{
    IM_DELETE(self);
}
CIMGUI_API ImPlotNextPlotData* ImPlotNextPlotData_ImPlotNextPlotData(void)
{
    return IM_NEW(ImPlotNextPlotData)();
}
CIMGUI_API void ImPlotNextPlotData_destroy(ImPlotNextPlotData* self)
{
    IM_DELETE(self);
}
CIMGUI_API void ImPlotNextPlotData_Reset(ImPlotNextPlotData* self)
{
    return self->Reset();
}
CIMGUI_API ImPlotNextItemData* ImPlotNextItemData_ImPlotNextItemData(void)
{
    return IM_NEW(ImPlotNextItemData)();
}
CIMGUI_API void ImPlotNextItemData_destroy(ImPlotNextItemData* self)
{
    IM_DELETE(self);
}
CIMGUI_API void ImPlotNextItemData_Reset(ImPlotNextItemData* self)
{
    return self->Reset();
}
CIMGUI_API void ImPlot_Initialize(ImPlotContext* ctx)
{
    return ImPlot::Initialize(ctx);
}
CIMGUI_API void ImPlot_ResetCtxForNextPlot(ImPlotContext* ctx)
{
    return ImPlot::ResetCtxForNextPlot(ctx);
}
CIMGUI_API void ImPlot_ResetCtxForNextAlignedPlots(ImPlotContext* ctx)
{
    return ImPlot::ResetCtxForNextAlignedPlots(ctx);
}
CIMGUI_API void ImPlot_ResetCtxForNextSubplot(ImPlotContext* ctx)
{
    return ImPlot::ResetCtxForNextSubplot(ctx);
}
CIMGUI_API ImPlotPlot* ImPlot_GetPlot(const char* title)
{
    return ImPlot::GetPlot(title);
}
CIMGUI_API ImPlotPlot* ImPlot_GetCurrentPlot()
{
    return ImPlot::GetCurrentPlot();
}
CIMGUI_API void ImPlot_BustPlotCache()
{
    return ImPlot::BustPlotCache();
}
CIMGUI_API void ImPlot_ShowPlotContextMenu(ImPlotPlot* plot)
{
    return ImPlot::ShowPlotContextMenu(*plot);
}
CIMGUI_API void ImPlot_SetupLock()
{
    return ImPlot::SetupLock();
}
CIMGUI_API void ImPlot_SubplotNextCell()
{
    return ImPlot::SubplotNextCell();
}
CIMGUI_API void ImPlot_ShowSubplotsContextMenu(ImPlotSubplot* subplot)
{
    return ImPlot::ShowSubplotsContextMenu(*subplot);
}
CIMGUI_API bool ImPlot_BeginItem(const char* label_id,ImPlotItemFlags flags,ImPlotCol recolor_from)
{
    return ImPlot::BeginItem(label_id,flags,recolor_from);
}
CIMGUI_API void ImPlot_EndItem()
{
    return ImPlot::EndItem();
}
CIMGUI_API ImPlotItem* ImPlot_RegisterOrGetItem(const char* label_id,ImPlotItemFlags flags,bool* just_created)
{
    return ImPlot::RegisterOrGetItem(label_id,flags,just_created);
}
CIMGUI_API ImPlotItem* ImPlot_GetItem(const char* label_id)
{
    return ImPlot::GetItem(label_id);
}
CIMGUI_API ImPlotItem* ImPlot_GetCurrentItem()
{
    return ImPlot::GetCurrentItem();
}
CIMGUI_API void ImPlot_BustItemCache()
{
    return ImPlot::BustItemCache();
}
CIMGUI_API bool ImPlot_AnyAxesInputLocked(ImPlotAxis* axes,int count)
{
    return ImPlot::AnyAxesInputLocked(axes,count);
}
CIMGUI_API bool ImPlot_AllAxesInputLocked(ImPlotAxis* axes,int count)
{
    return ImPlot::AllAxesInputLocked(axes,count);
}
CIMGUI_API bool ImPlot_AnyAxesHeld(ImPlotAxis* axes,int count)
{
    return ImPlot::AnyAxesHeld(axes,count);
}
CIMGUI_API bool ImPlot_AnyAxesHovered(ImPlotAxis* axes,int count)
{
    return ImPlot::AnyAxesHovered(axes,count);
}
CIMGUI_API bool ImPlot_FitThisFrame()
{
    return ImPlot::FitThisFrame();
}
CIMGUI_API void ImPlot_FitPointX(double x)
{
    return ImPlot::FitPointX(x);
}
CIMGUI_API void ImPlot_FitPointY(double y)
{
    return ImPlot::FitPointY(y);
}
CIMGUI_API void ImPlot_FitPoint(const ImPlotPoint_c p)
{
    return ImPlot::FitPoint(ConvertToCPP_ImPlotPoint(p));
}
CIMGUI_API bool ImPlot_RangesOverlap(const ImPlotRange_c r1,const ImPlotRange_c r2)
{
    return ImPlot::RangesOverlap(ConvertToCPP_ImPlotRange(r1),ConvertToCPP_ImPlotRange(r2));
}
CIMGUI_API void ImPlot_ShowAxisContextMenu(ImPlotAxis* axis,ImPlotAxis* equal_axis,bool time_allowed)
{
    return ImPlot::ShowAxisContextMenu(*axis,equal_axis,time_allowed);
}
CIMGUI_API ImVec2_c ImPlot_GetLocationPos(const ImRect_c outer_rect,const ImVec2_c inner_size,ImPlotLocation location,const ImVec2_c pad)
{
    return ConvertFromCPP_ImVec2(ImPlot::GetLocationPos(ConvertToCPP_ImRect(outer_rect),ConvertToCPP_ImVec2(inner_size),location,ConvertToCPP_ImVec2(pad)));
}
CIMGUI_API ImVec2_c ImPlot_CalcLegendSize(ImPlotItemGroup* items,const ImVec2_c pad,const ImVec2_c spacing,bool vertical)
{
    return ConvertFromCPP_ImVec2(ImPlot::CalcLegendSize(*items,ConvertToCPP_ImVec2(pad),ConvertToCPP_ImVec2(spacing),vertical));
}
CIMGUI_API bool ImPlot_ClampLegendRect(ImRect* legend_rect,const ImRect_c outer_rect,const ImVec2_c pad)
{
    return ImPlot::ClampLegendRect(*legend_rect,ConvertToCPP_ImRect(outer_rect),ConvertToCPP_ImVec2(pad));
}
CIMGUI_API bool ImPlot_ShowLegendEntries(ImPlotItemGroup* items,const ImRect_c legend_bb,bool interactable,const ImVec2_c pad,const ImVec2_c spacing,bool vertical,ImDrawList* DrawList)
{
    return ImPlot::ShowLegendEntries(*items,ConvertToCPP_ImRect(legend_bb),interactable,ConvertToCPP_ImVec2(pad),ConvertToCPP_ImVec2(spacing),vertical,*DrawList);
}
CIMGUI_API void ImPlot_ShowAltLegend(const char* title_id,bool vertical,const ImVec2_c size,bool interactable)
{
    return ImPlot::ShowAltLegend(title_id,vertical,ConvertToCPP_ImVec2(size),interactable);
}
CIMGUI_API bool ImPlot_ShowLegendContextMenu(ImPlotLegend* legend,bool visible)
{
    return ImPlot::ShowLegendContextMenu(*legend,visible);
}
CIMGUI_API void ImPlot_LabelAxisValue(const ImPlotAxis_c axis,double value,char* buff,int size,bool round)
{
    return ImPlot::LabelAxisValue(ConvertToCPP_ImPlotAxis(axis),value,buff,size,round);
}
CIMGUI_API const ImPlotNextItemData* ImPlot_GetItemData()
{
    return &ImPlot::GetItemData();
}
CIMGUI_API bool ImPlot_IsColorAuto_Vec4(const ImVec4_c col)
{
    return ImPlot::IsColorAuto(ConvertToCPP_ImVec4(col));
}
CIMGUI_API bool ImPlot_IsColorAuto_PlotCol(ImPlotCol idx)
{
    return ImPlot::IsColorAuto(idx);
}
CIMGUI_API ImVec4_c ImPlot_GetAutoColor(ImPlotCol idx)
{
    return ConvertFromCPP_ImVec4(ImPlot::GetAutoColor(idx));
}
CIMGUI_API ImVec4_c ImPlot_GetStyleColorVec4(ImPlotCol idx)
{
    return ConvertFromCPP_ImVec4(ImPlot::GetStyleColorVec4(idx));
}
CIMGUI_API ImU32 ImPlot_GetStyleColorU32(ImPlotCol idx)
{
    return ImPlot::GetStyleColorU32(idx);
}
CIMGUI_API void ImPlot_AddTextVertical(ImDrawList* DrawList,ImVec2_c pos,ImU32 col,const char* text_begin,const char* text_end)
{
    return ImPlot::AddTextVertical(DrawList,ConvertToCPP_ImVec2(pos),col,text_begin,text_end);
}
CIMGUI_API void ImPlot_AddTextCentered(ImDrawList* DrawList,ImVec2_c top_center,ImU32 col,const char* text_begin,const char* text_end)
{
    return ImPlot::AddTextCentered(DrawList,ConvertToCPP_ImVec2(top_center),col,text_begin,text_end);
}
CIMGUI_API ImVec2_c ImPlot_CalcTextSizeVertical(const char* text)
{
    return ConvertFromCPP_ImVec2(ImPlot::CalcTextSizeVertical(text));
}
CIMGUI_API ImU32 ImPlot_CalcTextColor_Vec4(const ImVec4_c bg)
{
    return ImPlot::CalcTextColor(ConvertToCPP_ImVec4(bg));
}
CIMGUI_API ImU32 ImPlot_CalcTextColor_U32(ImU32 bg)
{
    return ImPlot::CalcTextColor(bg);
}
CIMGUI_API ImU32 ImPlot_CalcHoverColor(ImU32 col)
{
    return ImPlot::CalcHoverColor(col);
}
CIMGUI_API ImVec2_c ImPlot_ClampLabelPos(ImVec2_c pos,const ImVec2_c size,const ImVec2_c Min,const ImVec2_c Max)
{
    return ConvertFromCPP_ImVec2(ImPlot::ClampLabelPos(ConvertToCPP_ImVec2(pos),ConvertToCPP_ImVec2(size),ConvertToCPP_ImVec2(Min),ConvertToCPP_ImVec2(Max)));
}
CIMGUI_API ImU32 ImPlot_GetColormapColorU32(int idx,ImPlotColormap cmap)
{
    return ImPlot::GetColormapColorU32(idx,cmap);
}
CIMGUI_API ImU32 ImPlot_NextColormapColorU32()
{
    return ImPlot::NextColormapColorU32();
}
CIMGUI_API ImU32 ImPlot_SampleColormapU32(float t,ImPlotColormap cmap)
{
    return ImPlot::SampleColormapU32(t,cmap);
}
CIMGUI_API void ImPlot_RenderColorBar(const ImU32* colors,int size,ImDrawList* DrawList,const ImRect_c bounds,bool vert,bool reversed,bool continuous)
{
    return ImPlot::RenderColorBar(colors,size,*DrawList,ConvertToCPP_ImRect(bounds),vert,reversed,continuous);
}
CIMGUI_API double ImPlot_NiceNum(double x,bool round)
{
    return ImPlot::NiceNum(x,round);
}
CIMGUI_API int ImPlot_OrderOfMagnitude(double val)
{
    return ImPlot::OrderOfMagnitude(val);
}
CIMGUI_API int ImPlot_OrderToPrecision(int order)
{
    return ImPlot::OrderToPrecision(order);
}
CIMGUI_API int ImPlot_Precision(double val)
{
    return ImPlot::Precision(val);
}
CIMGUI_API double ImPlot_RoundTo(double val,int prec)
{
    return ImPlot::RoundTo(val,prec);
}
CIMGUI_API ImVec2_c ImPlot_Intersection(const ImVec2_c a1,const ImVec2_c a2,const ImVec2_c b1,const ImVec2_c b2)
{
    return ConvertFromCPP_ImVec2(ImPlot::Intersection(ConvertToCPP_ImVec2(a1),ConvertToCPP_ImVec2(a2),ConvertToCPP_ImVec2(b1),ConvertToCPP_ImVec2(b2)));
}
CIMGUI_API void ImPlot_FillRange_Vector_Float_Ptr(ImVector_float * buffer,int n,float vmin,float vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_double_Ptr(ImVector_double * buffer,int n,double vmin,double vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_S8_Ptr(ImVector_ImS8 * buffer,int n,ImS8 vmin,ImS8 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_U8_Ptr(ImVector_ImU8 * buffer,int n,ImU8 vmin,ImU8 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_S16_Ptr(ImVector_ImS16 * buffer,int n,ImS16 vmin,ImS16 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_U16_Ptr(ImVector_ImU16 * buffer,int n,ImU16 vmin,ImU16 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_S32_Ptr(ImVector_ImS32 * buffer,int n,ImS32 vmin,ImS32 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_U32_Ptr(ImVector_ImU32 * buffer,int n,ImU32 vmin,ImU32 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_S64_Ptr(ImVector_ImS64 * buffer,int n,ImS64 vmin,ImS64 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_FillRange_Vector_U64_Ptr(ImVector_ImU64 * buffer,int n,ImU64 vmin,ImU64 vmax)
{
    return ImPlot::FillRange(*buffer,n,vmin,vmax);
}
CIMGUI_API void ImPlot_CalculateBins_FloatPtr(const float* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_doublePtr(const double* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_S8Ptr(const ImS8* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_U8Ptr(const ImU8* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_S16Ptr(const ImS16* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_U16Ptr(const ImU16* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_S32Ptr(const ImS32* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_U32Ptr(const ImU32* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_S64Ptr(const ImS64* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API void ImPlot_CalculateBins_U64Ptr(const ImU64* values,int count,ImPlotBin meth,const ImPlotRange_c range,int* bins_out,double* width_out)
{
    return ImPlot::CalculateBins(values,count,meth,ConvertToCPP_ImPlotRange(range),*bins_out,*width_out);
}
CIMGUI_API bool ImPlot_IsLeapYear(int year)
{
    return ImPlot::IsLeapYear(year);
}
CIMGUI_API int ImPlot_GetDaysInMonth(int year,int month)
{
    return ImPlot::GetDaysInMonth(year,month);
}
CIMGUI_API ImPlotTime_c ImPlot_MkGmtTime(struct tm* ptm)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::MkGmtTime(ptm));
}
CIMGUI_API tm* ImPlot_GetGmtTime(const ImPlotTime_c t,tm* ptm)
{
    return ImPlot::GetGmtTime(ConvertToCPP_ImPlotTime(t),ptm);
}
CIMGUI_API ImPlotTime_c ImPlot_MkLocTime(struct tm* ptm)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::MkLocTime(ptm));
}
CIMGUI_API tm* ImPlot_GetLocTime(const ImPlotTime_c t,tm* ptm)
{
    return ImPlot::GetLocTime(ConvertToCPP_ImPlotTime(t),ptm);
}
CIMGUI_API ImPlotTime_c ImPlot_MkTime(struct tm* ptm)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::MkTime(ptm));
}
CIMGUI_API tm* ImPlot_GetTime(const ImPlotTime_c t,tm* ptm)
{
    return ImPlot::GetTime(ConvertToCPP_ImPlotTime(t),ptm);
}
CIMGUI_API ImPlotTime_c ImPlot_MakeTime(int year,int month,int day,int hour,int min,int sec,int us)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::MakeTime(year,month,day,hour,min,sec,us));
}
CIMGUI_API int ImPlot_GetYear(const ImPlotTime_c t)
{
    return ImPlot::GetYear(ConvertToCPP_ImPlotTime(t));
}
CIMGUI_API int ImPlot_GetMonth(const ImPlotTime_c t)
{
    return ImPlot::GetMonth(ConvertToCPP_ImPlotTime(t));
}
CIMGUI_API ImPlotTime_c ImPlot_AddTime(const ImPlotTime_c t,ImPlotTimeUnit unit,int count)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::AddTime(ConvertToCPP_ImPlotTime(t),unit,count));
}
CIMGUI_API ImPlotTime_c ImPlot_FloorTime(const ImPlotTime_c t,ImPlotTimeUnit unit)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::FloorTime(ConvertToCPP_ImPlotTime(t),unit));
}
CIMGUI_API ImPlotTime_c ImPlot_CeilTime(const ImPlotTime_c t,ImPlotTimeUnit unit)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::CeilTime(ConvertToCPP_ImPlotTime(t),unit));
}
CIMGUI_API ImPlotTime_c ImPlot_RoundTime(const ImPlotTime_c t,ImPlotTimeUnit unit)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::RoundTime(ConvertToCPP_ImPlotTime(t),unit));
}
CIMGUI_API ImPlotTime_c ImPlot_CombineDateTime(const ImPlotTime_c date_part,const ImPlotTime_c time_part)
{
    return ConvertFromCPP_ImPlotTime(ImPlot::CombineDateTime(ConvertToCPP_ImPlotTime(date_part),ConvertToCPP_ImPlotTime(time_part)));
}
CIMGUI_API ImPlotTime_c ImPlot_Now()
{
    return ConvertFromCPP_ImPlotTime(ImPlot::Now());
}
CIMGUI_API ImPlotTime_c ImPlot_Today()
{
    return ConvertFromCPP_ImPlotTime(ImPlot::Today());
}
CIMGUI_API int ImPlot_FormatTime(const ImPlotTime_c t,char* buffer,int size,ImPlotTimeFmt fmt,bool use_24_hr_clk)
{
    return ImPlot::FormatTime(ConvertToCPP_ImPlotTime(t),buffer,size,fmt,use_24_hr_clk);
}
CIMGUI_API int ImPlot_FormatDate(const ImPlotTime_c t,char* buffer,int size,ImPlotDateFmt fmt,bool use_iso_8601)
{
    return ImPlot::FormatDate(ConvertToCPP_ImPlotTime(t),buffer,size,fmt,use_iso_8601);
}
CIMGUI_API int ImPlot_FormatDateTime(const ImPlotTime_c t,char* buffer,int size,ImPlotDateTimeSpec_c fmt)
{
    return ImPlot::FormatDateTime(ConvertToCPP_ImPlotTime(t),buffer,size,ConvertToCPP_ImPlotDateTimeSpec(fmt));
}
CIMGUI_API bool ImPlot_ShowDatePicker(const char* id,int* level,ImPlotTime* t,const ImPlotTime* t1,const ImPlotTime* t2)
{
    return ImPlot::ShowDatePicker(id,level,t,t1,t2);
}
CIMGUI_API bool ImPlot_ShowTimePicker(const char* id,ImPlotTime* t)
{
    return ImPlot::ShowTimePicker(id,t);
}
CIMGUI_API double ImPlot_TransformForward_Log10(double v,void* noname1)
{
    return ImPlot::TransformForward_Log10(v,noname1);
}
CIMGUI_API double ImPlot_TransformInverse_Log10(double v,void* noname1)
{
    return ImPlot::TransformInverse_Log10(v,noname1);
}
CIMGUI_API double ImPlot_TransformForward_SymLog(double v,void* noname1)
{
    return ImPlot::TransformForward_SymLog(v,noname1);
}
CIMGUI_API double ImPlot_TransformInverse_SymLog(double v,void* noname1)
{
    return ImPlot::TransformInverse_SymLog(v,noname1);
}
CIMGUI_API double ImPlot_TransformForward_Logit(double v,void* noname1)
{
    return ImPlot::TransformForward_Logit(v,noname1);
}
CIMGUI_API double ImPlot_TransformInverse_Logit(double v,void* noname1)
{
    return ImPlot::TransformInverse_Logit(v,noname1);
}
CIMGUI_API int ImPlot_Formatter_Default(double value,char* buff,int size,void* data)
{
    return ImPlot::Formatter_Default(value,buff,size,data);
}
CIMGUI_API int ImPlot_Formatter_Logit(double value,char* buff,int size,void* noname1)
{
    return ImPlot::Formatter_Logit(value,buff,size,noname1);
}
CIMGUI_API int ImPlot_Formatter_Time(double noname1,char* buff,int size,void* data)
{
    return ImPlot::Formatter_Time(noname1,buff,size,data);
}
CIMGUI_API void ImPlot_Locator_Default(ImPlotTicker* ticker,const ImPlotRange_c range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)
{
    return ImPlot::Locator_Default(*ticker,ConvertToCPP_ImPlotRange(range),pixels,vertical,formatter,formatter_data);
}
CIMGUI_API void ImPlot_Locator_Time(ImPlotTicker* ticker,const ImPlotRange_c range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)
{
    return ImPlot::Locator_Time(*ticker,ConvertToCPP_ImPlotRange(range),pixels,vertical,formatter,formatter_data);
}
CIMGUI_API void ImPlot_Locator_Log10(ImPlotTicker* ticker,const ImPlotRange_c range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)
{
    return ImPlot::Locator_Log10(*ticker,ConvertToCPP_ImPlotRange(range),pixels,vertical,formatter,formatter_data);
}
CIMGUI_API void ImPlot_Locator_SymLog(ImPlotTicker* ticker,const ImPlotRange_c range,float pixels,bool vertical,ImPlotFormatter formatter,void* formatter_data)
{
    return ImPlot::Locator_SymLog(*ticker,ConvertToCPP_ImPlotRange(range),pixels,vertical,formatter,formatter_data);
}

