// This source code is subject to the terms of the Mozilla Public License 2.

0 at
https://mozilla.org/MPL/2.0/
// © wielkieef

//@version=4

strategy("0110 BOT", overlay = true, pyramiding=1,initial_capital = 10000,

default_qty_type= strategy.percent_of_equity, default_qty_value = 100,
calc_on_order_fills=false,
slippage=0,commission_type=strategy.commission.percent,commission_value=0.03)

//SOURCE
===================================================================================
===================================================================================
===================================================================================
====================================================

src = input(open,
title=" Source")

// Inputs
===================================================================================
===================================================================================
===================================================================================
===============================================

//ADX
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------

ADX_options = input("MASANAKAMURA",
title=" Adx Option", options = ["CLASSIC",
"MASANAKAMURA"], group = "ADX")
ADX_len = input(21,
title=" Adx Lenght", type = input.integer,
minval = 1, group = "ADX")
th = input(20,
title=" Adx Treshold", type = input.float,
minval = 0, step = 0.5, group = "ADX")

//
MACD-------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------

fast_length = input(15,
title=" Fast Length", type=input.integer,
group="MACD")
slow_length = input(16,
title=" Slow Length", type=input.integer,
group="MACD")
signal_length = input(26,
title=" Signal Smoothing", type=input.integer,
group="MACD")
// Range Filter
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
------------------------------------------------

per_ = input(15,
title=" Period", minval=1,
group = "Range Filter")
mult = input(2.6,
title=" mult.", minval=0.1, step =
0.1, group = "Range
Filter")

//
SAR--------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------------------------------------------------------

SHOW_SAR = input(true,
title="Show Parabolic SAR",
group="SAR")
Sst = input (0.5,
title=" Sar Start", step=0.01, minval =
0.01, group="SAR")
Sinc = input (0.2,
title=" Sar Int", step=0.01, minval =
0.01, group="SAR")
Smax = input (0.4,
title=" Sar Max", step=0.01, minval =
0.01, group="SAR")

// Volume
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
---------------------------------------------------

volume_f = input(3.2,
title=" Volume mult.", minval = 0, step =
0.1, group="Volume")
sma_length = input(20,
title=" Volume lenght", minval = 1,
group="Volume")

volume_f1 = input(1.9,
title=" Volume mult. 1", minval = 0, step
= 0.1, group="Volume")
sma_length1 = input(22,
title=" Volume lenght 1", minval = 1,
group="Volume")

//BOLINGER BANDS
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------------------------------
SHOW_BB = input(true,
title="Show Bollinger Bands",
group="Bolinger Bands")
tf2 = input("",
title=" Timeframe 2", type =
input.resolution,
group="Bolinger Bands")
src2 = input(high,
title=" Source 2", type = input.source,
group="Bolinger Bands")

//TP PLOTSHAPE
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------------------------------------

tp_long0 = input(0.9,
title=" % TP Long", type = input.float,
minval = 0, step = 0.1, group="Target Point")
tp_short0 = input(0.9,
title=" % TP Short", type = input.float,
minval = 0, step = 0.1, group="Target Point")

// SL PLOTSHAPE
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
------------------------------------------------------

sl0 = input(4.2,
title=" % Stop loss", type = input.float,
minval = 0, step = 0.1, group="Stop Loss")

//INDICATORS
===================================================================================
===================================================================================
===================================================================================
==============================================

//
ADX--------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------------------------------------------

calcADX(_len) =>
up =
change(high)
down =
-change(low)
plusDM =
na(up) ? na : (up > down and up > 0 ? up : 0)
minusDM =
na(down) ? na : (down > up and down > 0 ? down : 0)
truerange =
rma(tr, _len)
 _plus =
fixnan(100 * rma(plusDM, _len) / truerange)
_minus =
fixnan(100 * rma(minusDM, _len) / truerange)
sum =
_plus + _minus
_adx =
100 * rma(abs(_plus - _minus) / (sum == 0 ? 1 : sum), _len)
[_plus,_minus,_adx]
calcADX_Masanakamura(_len) =>
SmoothedTrueRange =
0.0
SmoothedDirectionalMovementPlus =
0.0
SmoothedDirectionalMovementMinus =
0.0
TrueRange =
max(max(high - low, abs(high - nz(close[1]))), abs(low - nz(close[1])))
DirectionalMovementPlus =
high - nz(high[1]) > nz(low[1]) - low ? max(high - nz(high[1]), 0) : 0
DirectionalMovementMinus =
nz(low[1]) - low > high - nz(high[1]) ? max(nz(low[1]) - low, 0) : 0
SmoothedTrueRange :=
nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1]) /_len) + TrueRange
SmoothedDirectionalMovementPlus :=
nz(SmoothedDirectionalMovementPlus[1]) -
(nz(SmoothedDirectionalMovementPlus[1]) / _len) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus :=
nz(SmoothedDirectionalMovementMinus[1]) -
(nz(SmoothedDirectionalMovementMinus[1]) / _len) + DirectionalMovementMinus
DIP =
SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIM =
SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX =
abs(DIP-DIM) / (DIP+DIM)*100
adx =
sma(DX, _len)
[DIP,DIM,adx]
[DIPlusC,DIMinusC,ADXC] =
calcADX(ADX_len)
[DIPlusM,DIMinusM,ADXM] =
calcADX_Masanakamura(ADX_len)

DIPlus =
ADX_options == "CLASSIC" ? DIPlusC : DIPlusM
DIMinus =
ADX_options == "CLASSIC" ? DIMinusC : DIMinusM
ADX =
ADX_options == "CLASSIC" ? ADXC : ADXM
L_adx =
DIPlus > DIMinus and ADX > th
S_adx =
DIPlus < DIMinus and ADX > th

//
MACD-------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
------------------------------------------------------------

fast_ma =
ema(src, fast_length)
slow_ma =
ema(src, slow_length)
macd =
fast_ma - slow_ma
signal_ =
sma(macd, signal_length)
L_macd =
macd > signal_
S_macd =
macd < signal_

// Range Filter
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------------------------

var bool L_RF = na, var bool S_RF = na

Range_filter(_src, _per_, _mult)=>

var float _upward =
0.0
var float _downward =
0.0
wper =
(_per_*2) - 1
avrng =
ema(abs(_src - _src[1]), _per_)
_smoothrng =
ema(avrng, wper)*_mult
_filt =
_src
_filt :=
_src > nz(_filt[1]) ? ((_src-_smoothrng) < nz(_filt[1]) ? nz(_filt[1]) : (_src-
_smoothrng)) : ((_src+_smoothrng) > nz(_filt[1]) ? nz(_filt[1]) :
(_src+_smoothrng))
_upward :=
_filt > _filt[1] ? nz(_upward[1]) + 1 : _filt < _filt[1] ? 0 : nz(_upward[1])
_downward :=
_filt < _filt[1] ? nz(_downward[1]) + 1 : _filt > _filt[1] ? 0 : nz(_downward[1])
[_smoothrng,_filt,_upward,_downward]
[smoothrng, filt, upward, downward] = Range_filter(src, per_, mult)
hband =
filt + smoothrng
lband =
filt - smoothrng
L_RF :=
high > hband and upward > 0
S_RF := low
< lband and downward > 0

//
SAR--------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
------------------------------------------------------------------------

SAR =
sar(Sst, Sinc, Smax)
L_sar =
(SAR < close)
S_sar =
(SAR > close)

// Volume
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------------------------------------------

Volume_condt =
volume > sma(volume,sma_length)*volume_f
Volume_condt1 =
volume > sma(volume,sma_length1)*volume_f1

// BOLINGER BADNS
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
----------------------------------------------------------------------

per2 =
input(20)
dev2 =
input(3.0)
ma2 =
security(syminfo.tickerid, tf2, sma(src2, per2))

hb2 =
ma2 + security(syminfo.tickerid, tf2, stdev(src2, per2)) * dev2
lb2 =
ma2 - security(syminfo.tickerid, tf2, stdev(src2, per2)) * dev2

L_BB_2 = close > hb2

S_BB_2 = close > lb2

L_BB_CROSS = crossunder(close, lb2)

S_BB_CROSS = crossunder(close, hb2)

//STRATEGY
===================================================================================
===================================================================================
===================================================================================
=================================================

var bool longCond = na, var bool shortCond = na

var int CondIni_long = 0, var int CondIni_short = 0
var bool _Final_longCondition = na, var bool _Final_shortCondition = na
var float last_open_longCondition = na, var float last_open_shortCondition = na
var int last_longCondition = na, var int last_shortCondition = na
var int last_Final_longCondition = na, var int last_Final_shortCondition = na
var int nLongs = na, var int nShorts = na

L_1 =
L_BB_CROSS and Volume_condt and L_RF
S_1 =
S_BB_CROSS and Volume_condt and S_RF

L_2 =
L_adx and L_RF and L_macd and L_sar and Volume_condt1
S_2 =
S_adx and S_RF and S_macd and S_sar and Volume_condt1

L_basic_condt = L_1 or L_2

S_basic_condt = S_1 or S_2

longCond :=
L_basic_condt
shortCond :=
S_basic_condt

CondIni_long := longCond[1] ? 1 :
shortCond[1] ? -1 : nz(CondIni_long[1]
)
CondIni_short := longCond[1] ? 1 :
shortCond[1] ? -1 : nz(CondIni_short[1]
)
longCondition = (longCond[1] and
nz(CondIni_long[1]) == -1 )
shortCondition = (shortCond[1] and
nz(CondIni_short[1]) == 1 )

//POSITION
PRICE------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------------------------------

var float sum_long = 0.0, var float sum_short = 0.0

var float Position_Price = 0.0
var bool Final_long_BB = na, var bool Final_short_BB = na
var int last_long_BB = na, var int last_short_BB = na

last_open_longCondition := longCondition or
Final_long_BB[1] ? close[1] : nz(last_open_longCondition[1]
)
last_open_shortCondition := shortCondition or
Final_short_BB[1] ? close[1] : nz(last_open_shortCondition[1]
)
last_longCondition := longCondition or
Final_long_BB[1] ? time : nz(last_longCondition[1]
)
last_shortCondition := shortCondition or
Final_short_BB[1] ? time : nz(last_shortCondition[1]
)
in_longCondition = last_longCondition >
last_shortCondition
in_shortCondition = last_shortCondition >
last_longCondition
last_Final_longCondition := longCondition ?
time :
nz(last_Final_longCondition[1] )
last_Final_shortCondition := shortCondition ?
time :
nz(last_Final_shortCondition[1] )
nLongs := nz(nLongs[1]
)
nShorts := nz(nShorts[1]
)
if longCondition or Final_long_BB
nLongs := nLongs + 1
nShorts := 0
sum_long := nz(last_open_longCondition) +
nz(sum_long[1])
sum_short := 0.0
if shortCondition or Final_short_BB
nLongs := 0
nShorts := nShorts + 1
sum_short := nz(last_open_shortCondition)+
nz(sum_short[1])
sum_long := 0.0

Position_Price := nz(Position_Price[1])

Position_Price := longCondition or
Final_long_BB ? sum_long/nLongs : shortCondition or
Final_short_BB ? sum_short/nShorts : na

//
TP---------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------------------------------------------------------

var bool long_tp = na, var bool short_tp = na

var int last_long_tp = na, var int last_short_tp = na
var bool Final_Long_tp = na, var bool Final_Short_tp = na
var bool Final_Long_sl0 = na, var bool Final_Short_sl0 = na
var bool Final_Long_sl = na, var bool Final_Short_sl = na
var int last_long_sl = na, var int last_short_sl = na

tp_long = ((nLongs > 1) ?

tp_long0 / nLongs : tp_long0) / 100
tp_short = ((nShorts > 1) ?
tp_short0 / nShorts : tp_short0) / 100
long_tp := high >
(fixnan(Position_Price) * (1 + tp_long)) and
in_longCondition
short_tp := low <
(fixnan(Position_Price) * (1 - tp_short)) and
in_shortCondition
last_long_tp := long_tp ?
time : nz(last_long_tp[1])
last_short_tp := short_tp ?
time : nz(last_short_tp[1])
Final_Long_tp := (long_tp and
last_longCondition > nz(last_long_tp[1]) and
last_longCondition > nz(last_long_sl[1]))
Final_Short_tp := (short_tp and
last_shortCondition > nz(last_short_tp[1]) and
last_shortCondition > nz(last_short_sl[1]))
L_tp = iff(Final_Long_tp,
fixnan(Position_Price) * (1 + tp_long) ,
na)
S_tp = iff(Final_Short_tp,
fixnan(Position_Price) * (1 - tp_short) ,
na)

//TP
SIGNALS----------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
------------------------------------------------------------------

tplLevel = (in_longCondition and

(last_longCondition >
nz(last_long_tp[1])) and
(last_longCondition >
nz(last_long_sl[1])) and not Final_Long_sl[1]) ?
(nLongs > 1) ?
(fixnan(Position_Price) * (1
+ tp_long)) : (last_open_longCondition *
(1 + tp_long)) : na
tpsLevel = (in_shortCondition and
(last_shortCondition >
nz(last_short_tp[1])) and
(last_shortCondition >
nz(last_short_sl[1])) and not Final_Short_sl[1]) ?
(nShorts > 1) ?
(fixnan(Position_Price) * (1
- tp_short)) : (last_open_shortCondition *
(1 - tp_short)) : na

//SL
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
------------------------------------------------------

Risk = sl0
Percent_Capital = 99

sl = in_longCondition ? min(sl0,(((Risk) * 100) /

(Percent_Capital * max(1, nLongs)))) :
in_shortCondition ? min(sl0,(((Risk) * 100) /
(Percent_Capital * max(1, nShorts)))) : sl0

Normal_long_sl = ((in_longCondition and low

<= ((1 - (sl / 100)) * (fixnan(Position_Price)))))
Normal_short_sl = ((in_shortCondition and high
>= ((1 + (sl / 100)) * (fixnan(Position_Price)))))
last_long_sl := Normal_long_sl ? time :
nz(last_long_sl[1])
last_short_sl := Normal_short_sl ? time :
nz(last_short_sl[1])
Final_Long_sl := Normal_long_sl and last_longCondition
> nz(last_long_sl[1]) and last_longCondition > nz(last_long_tp[1])
and not Final_Long_tp
Final_Short_sl := Normal_short_sl and last_shortCondition
> nz(last_short_sl[1]) and last_shortCondition > nz(last_short_tp[1])
and not Final_Short_tp
//RE-ENTRY ON TP-
HIT--------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------

if Final_Long_tp or
Final_Long_sl
CondIni_long := -1
sum_long := 0.0
nLongs := na

if Final_Short_tp or
Final_Short_sl
CondIni_short := 1
sum_short := 0.0
nShorts := na

// Leverage
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
------------------------------------------------

var float last_leverage_L = na, var float last_leverage_S = na

Act_Lev = input(true,
title="Activate leverage?"
)
Max_Lev = input(2,
title="Max lev.",
type = input.integer, minval = 1, maxval = 5 )
sma_length_lev = input(20,
title="Volume lenght lev.",
minval = 1 )

long = ((longCond and not in_longCondition) or (longCond and Final_Long_tp) or

(longCond and Final_Long_sl)) or (longCond and not longCondition and (last_long_tp
> nz(last_longCondition))) or (longCond and not longCondition and (last_long_sl >
nz(last_longCondition)))
Long = (longCond and not in_longCondition) or (longCond and Final_Long_tp) or
(longCond and Final_Long_sl) or (longCond and not longCondition and (last_long_tp
>= nz(last_longCondition))) or (longCond and not longCondition and (last_long_sl >=
nz(last_longCondition)))
short = ((shortCond and not in_shortCondition) or (shortCond and Final_Short_tp) or
(shortCond and Final_Short_sl)) or (shortCond and not shortCondition and
(last_short_tp > nz(last_shortCondition))) or (shortCond and not shortCondition and
(last_short_sl > nz(last_shortCondition)))
Short = (shortCond and not in_shortCondition) or (shortCond and Final_Short_tp)
or (shortCond and Final_Short_sl) or (shortCond and not shortCondition and
(last_short_tp >= nz(last_shortCondition))) or (shortCond and not shortCondition
and (last_short_sl >= nz(last_shortCondition)))

Lev_vol = Act_Lev ?
min(Max_Lev,max(1, round(volume/sma(volume,sma_length_lev)))) : 1
rsiLen = 14
last_leverage_L := Long ? Lev_vol
: nz(last_leverage_L[1] )
last_leverage_S := Short ? Lev_vol
: nz(last_leverage_S[1] )

vol_x1 = Lev_vol[1] == 1
vol_x2 = Lev_vol[1] == 2

Long_x1 = longCondition and vol_x1

Short_x1 = shortCondition and vol_x1

Long_x2 = longCondition and vol_x2

Short_x2 = shortCondition and vol_x2

// Colors
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------------------------------

Bar_color = in_longCondition ? #009688 : in_shortCondition ? #f06292 : color.orange

barcolor
(color = Bar_color)

//
PLOTS==============================================================================
===================================================================================
===================================================================================
==========================================================

h_BB = plot(SHOW_BB ? hb2 : na, title = "Upper

Bollinger Band",
color = #009688, linewidth = 1 )
l_BB = plot(SHOW_BB ? lb2 : na, title = "Lower
Bollinger Band",
color = #f06292, linewidth = 1 )
fill(h_BB, l_BB, title = "Bollinger Band
Background",
color = in_longCondition ? #009688 : #f06292, transp = 95 )

plot(SHOW_SAR ? SAR : na, title = "SAR",

style=plot.style_circles,
color= Bar_color )

plot(L_tp, title = "TP_L",

style = plot.style_cross,
color = color.fuchsia, linewidth = 7 )
plot(S_tp, title = "TP_S",
style = plot.style_cross,
color = color.fuchsia, linewidth = 7 )

//Price plots
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
---------------------------------------------

plot((nLongs > 1) or (nShorts > 1) ? Position_Price : na, title = "Price", color =

in_longCondition ? color.aqua : color.orange, linewidth = 2, style =
plot.style_cross)
plot(tplLevel, title="Long TP ", style =
plot.style_cross,
color=color.fuchsia,
linewidth = 1 )
plot(tpsLevel, title="Short TP ", style =
plot.style_cross,
color=color.fuchsia,
linewidth = 1 )

//
PLOTSHAPES-------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------

plotshape(Long_x1, title = "L x2",

style=shape.triangleup, location=location.belowbar,
color=color.blue, size=size.tiny , text="x2",
textcolor=color.blue, transp = 0 )
plotshape(Short_x1, title = "S x2",
style=shape.triangledown, location=location.abovebar,
color=color.red, size=size.tiny , text="x2",
textcolor=color.red, transp = 0 )

plotshape(Long_x2, title = "L x4",

style=shape.triangleup, location=location.belowbar,
color=color.blue, size=size.tiny , text="x4",
textcolor=color.blue, transp = 0 )
plotshape(Short_x2, title = "S x4",
style=shape.triangledown, location=location.abovebar,
color=color.red, size=size.tiny, text="x4",
textcolor=color.red, transp = 0 )

plotshape(Final_Long_tp, title="TP Long Signal", style =

shape.triangledown, location=location.abovebar,
color=color.red, size=size.tiny , text="TP",
textcolor=color.red, transp = 0 )
plotshape(Final_Short_tp, title="TP Short Signal", style =
shape.triangleup, location=location.belowbar,
color=color.green, size=size.tiny , text="TP",
textcolor=color.green, transp = 0 )

plotshape(longCondition, title="Long",
style=shape.triangleup, location=location.belowbar,
color=color.blue, size=size.tiny ,
transp = 0 )
plotshape(shortCondition, title="Short",
style=shape.triangledown, location=location.abovebar,
color=color.red, size=size.tiny ,
transp = 0 )

//BACKTESTING inputs
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------------------------------------------

ACT_BT = input(true,
title="Backtest", type = input.bool,
group= "BACKTEST")
testStartYear = input(1997,
title="start year", minval = 1997, maxval =
3000, group= "BACKTEST")
testStartMonth = input(06,
title="start month", minval = 1, maxval =
12, group= "BACKTEST")
testStartDay = input(01,
title="start day", minval = 1, maxval =
31, group= "BACKTEST")
testPeriodStart =
timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(3333,
title="stop year", minval=1980, maxval =
2222, group= "BACKTEST")
testStopMonth = input(12,
title="stop month", minval=1, maxval=12,
group= "BACKTEST")
testStopDay = input(31,
title="stop day", minval=1, maxval=31,
group= "BACKTEST")
testPeriodStop = timestamp(testStopYear, testStopMonth,
testStopDay, 0, 0)
testPeriod = time >= testPeriodStart and time <=
testPeriodStop ? true : false

// Backtest
===================================================================================
===================================================================================
===================================================================================
=========================================================================

Lev_vol:= Lev_vol / 400

if
L_basic_condt
strategy.entry
("L", strategy.long , when = ACT_BT and testPeriod , qty = 2*Lev_vol)
if
S_basic_condt
strategy.entry
("S", strategy.short, when = ACT_BT and testPeriod , qty = 2*Lev_vol)

strategy.exit("TP_L", "L", profit = (abs((last_open_longCondition * (1 + tp_long))

- last_open_longCondition) / syminfo.mintick), limit = nLongs >= 1 ?
strategy.position_avg_price * (1 + tp_long) : na, loss =
(abs((last_open_longCondition*(1-(sl/100)))-last_open_longCondition)/
syminfo.mintick))

strategy.exit("TP_S", "S", profit = (abs((last_open_shortCondition * (1 -

tp_short)) - last_open_shortCondition) / syminfo.mintick), limit = nShorts >= 1 ?
strategy.position_avg_price*(1-(tp_short)) : na, loss =
(abs((last_open_shortCondition*(1+(sl/100)))-last_open_shortCondition)/
syminfo.mintick))
//By wielkieef