KaneAI - World’s First E2E Software Testing Agent.Book a Demo 
How to use is_var method in Robotframework
Best Python code snippet using robotframework
compiler.py
Source:compiler.py 
...565 return (lexpos - line_start) + 1566parser = yacc.yacc()567source_text += "\n"568parser.parse(source_text)569def is_var(thing):570 if not isinstance(thing, str):571 return thing572 if thing == "TRUE":573 return "1"574 if thing == "FALSE":575 return "0"576 if "tmp_" in thing:577 return "r"+(thing.replace("tmp_", ""))578 if thing[-1] == "]":579 m = re.search(r"\[(.*)\]", thing)580 t = m.group(1)581 m = re.search(r"(.*)\[.*\]", thing)582 thing = m.group(1)+"+"+t583 return "["+thing+"]"584def var_type(size):585 if size == 1:586 return "DB"587 else:588 return ".space {}".format(size)589def jump_type(comp):590 op = ["!=", "==", ">=", "<=", ">", "<"]591 ret = ["jnz", "jz", "jge", "jle", "jg", "jl"]592 return ret[op.index(comp)]593def quad_to_asm_jump(j):594 if j == "BZ":595 return "jz"596 elif j == "BGE":597 return "jge"598def quad_to_asm_op(o):599 op = ["+", "-", "*", "/"]600 ret = ["add", "sub", "mul", "div"]601 return ret[op.index(o)]602def asm(quads):603 output2 = []604 output2.append("section .data")605 for name, value in table_symbols._symbols.items():606 output2.append(name+" "+var_type(value.size))607 output2.append("section .start")608 output = []609 labels = []610 i = 0611 label_counter = 1612 for quad in quads:613 if quad[0] == "=":614 if not is_var(quad[1]) and type(quad[1]) is str:615 output.append([i, "mov {}, '{}'".format(is_var(quad[3]), quad[1])])616 else:617 output.append([i, "mov {}, {}".format(is_var(quad[3]), is_var(quad[1]))])618 elif quad[0] in ["+", "-", "/", "*"]:619 if quad[1] == quad[3]:620 output.append([i, "mov rax, {}".format(is_var(quad[3]))])621 if quad[2] == 1:622 if quad[0] == "-":623 output.append([i, "dec rax"])624 elif quad[0] == "+":625 output.append([i, "inc rax"])626 else:627 output.append([i, "{} rax, {}".format(quad_to_asm_op(quad[0]), is_var(quad[2]))])628 output.append([i, "mov {}, rax".format(is_var(quad[3]))])629 else:630 output.append([i, "mov {}, {}".format(is_var(quad[3]), is_var(quad[1]))])631 output.append([i, "{} {}, {}".format(quad_to_asm_op(quad[0]), is_var(quad[3]), is_var(quad[2]))])632 elif quad[0] in ["!=", "==", ">=", "<=", "<", ">"]:633 output.append([i, "mov {}, {}".format(is_var(quad[3]), is_var(quad[1]))])634 output.append([i, "sub {}, {}".format(is_var(quad[3]), is_var(quad[2]))])635 output.append([i, "cmp {}, 0".format(is_var(quad[3]))])636 output.append([i, "{} .label_{}".format(jump_type(quad[0]), label_counter)])637 output.append([i, "mov {}, 0".format(is_var(quad[3]))])638 output.append([i, "jmp .label_{}".format(label_counter+1)])639 output.append([i, ".label_{}".format(label_counter)])640 output.append([i, "mov {}, 1".format(is_var(quad[3]))])641 output.append([i, ".label_{}".format(label_counter+1)])642 label_counter += 2643 elif quad[0] in ["AND", "OR"]:644 output.append([i, "mov {}, {}".format(is_var(quad[3]), is_var(quad[1]))])645 output.append([i, "{} {}, {}".format(quad[0].lower(), is_var(quad[3]), is_var(quad[2]))])646 elif quad[0] == "BZ":647 output.append([i, "cmp {}, 0".format(is_var(quad[2]))])648 output.append([i, "{} .label_{}".format(quad_to_asm_jump(quad[0]), label_counter)])649 labels.append([quad[1], label_counter])650 label_counter += 1651 elif quad[0] == "BGE":652 output.append([i, "cmp {}, {}".format(is_var(quad[2]), is_var(quad[3]))])653 output.append([i, "{} .label_{}".format(quad_to_asm_jump(quad[0]), label_counter)])654 labels.append([quad[1], label_counter])655 label_counter += 1656 elif quad[0] == "BR":657 output.append([i, "jmp .label_{}".format(label_counter)])658 labels.append([quad[1], label_counter])659 label_counter += 1660 i += 1661 output.append([output[-1][0]+1, "END"])662 for inst in output:663 to_delete = []664 for k, label in enumerate(labels):665 if label[0] == inst[0]:666 output2.append(".label_{}".format(label[1]))...
stereo_project.py
Source:stereo_project.py
...171 penalty = 0.172 for row in range(disparity.shape[0]):173 for col in range(disparity.shape[1]):174 n = (disparity.shape[1] * row) + col175 if is_var(varsA[n]):176 col = varsA[n]["cord"]177 a = varsA[n]["alpha"]178 D = squared_dissimilarity(left_img, right_img, col, (col[0], int(col[1] + a))) - K179 g.add_tedge(varsAnodes[n], D, 0)180 if varsA[n] == VAR_ALPHA:181 col = (row, col)182 a = alpha183 D = squared_dissimilarity(left_img, right_img, col, (col[0], int(col[1] + a))) - K184 penalty += D185 if is_var(varsO[n]):186 col = varsO[n]["cord"]187 a = varsO[n]["alpha"]188 D = squared_dissimilarity(left_img, right_img, col, (col[0], int(col[1] + a))) - K189 g.add_tedge(varsOnodes[n], 0, D)190 for row in range(disparity.shape[0]):191 for col in range(disparity.shape[1]):192 i1 = (disparity.shape[1] * row) + col193 if is_var(varsO[i1]) and is_var(varsA[i1]):194 forbid01(g, varsOnodes[i1], varsAnodes[i1])195 ia = int(varsO[i1]["alpha"])196 c2 = col + ia - alpha197 i2 = (disparity.shape[1] * row) + c2198 forbid01(g, varsOnodes[i1], varsAnodes[i2])199 indices = (col, row)200 if indices[0] != disparity.shape[1] - 1:201 r2 = row202 c2 = col + (1)203 if c2 + alpha < disparity.shape[1]:204 i2 = (disparity.shape[1] * r2) + c2205 pen = K / 5206 d1 = int(left_img[row, col] - left_img[r2, c2])207 d2 = int(right_img[row, col + alpha] - right_img[r2, c2 + alpha])208 if max(d1, d2) < 8:209 pen *= 3.210 if is_var(varsA[i1]):211 if is_var(varsA[i2]):212 pairwise_term(g, varsAnodes[i1], varsAnodes[i2], 0, pen, pen, 0) # add term213 if is_var(varsO[i1]):214 if is_var(varsO[i2]):215 pairwise_term(g, varsAnodes[i1], varsAnodes[i2], 0, pen, pen, 0) # add term216 if is_var(varsA[i1]) and varsA[i2] == VAR_ALPHA:217 g.add_tedge(varsAnodes[i1], 0, pen)218 if is_var(varsA[i2]) and varsA[i1] == VAR_ALPHA:219 g.add_tedge(varsAnodes[i2], 0, pen)220 if is_var(varsO[i1]) and not is_var(varsO[i2]):221 g.add_tedge(varsOnodes[i1], 0, pen)222 if is_var(varsO[i2]) and not is_var(varsO[i1]):223 g.add_tedge(varsOnodes[i2], 0, pen)224 if indices[1] != disparity.shape[0] - 1:225 r2 = row + 1226 c2 = col227 if c2 + alpha < disparity.shape[1]:228 i2 = (disparity.shape[1] * r2) + c2229 pen = K / 5230 d1 = int(left_img[row, col] - left_img[r2, c2])231 d2 = int(right_img[row, col + alpha] - right_img[r2, c2 + alpha])232 if max(d1, d2) < 8:233 pen *= 3.234 if is_var(varsA[i1]):235 if is_var(varsA[i2]):236 pairwise_term(g, varsAnodes[i1], varsAnodes[i2], 0, pen, pen,237 0)238 if is_var(varsO[i1]):239 if is_var(varsO[i2]):240 pairwise_term(g, varsAnodes[i1], varsAnodes[i2], 0, pen, pen,241 0)242 if is_var(varsA[i1]) and varsA[i2] == VAR_ALPHA:243 g.add_tedge(varsAnodes[i1], 0, pen)244 if is_var(varsA[i2]) and varsA[i1] == VAR_ALPHA:245 g.add_tedge(varsAnodes[i2], 0, pen)246 if is_var(varsO[i1]) and not is_var(varsO[i2]):247 g.add_tedge(varsOnodes[i1], 0, pen)248 if is_var(varsO[i2]) and not is_var(varsO[i1]):249 g.add_tedge(varsOnodes[i2], 0, pen)250 flow = g.maxflow()251 energy = flow + penalty252 if energy < prev_e:253 prev_e = energy254 for row in range(disparity.shape[0]):255 for col in range(disparity.shape[1]):256 i = (disparity.shape[1] * row) + col257 if varsOnodes[i] != -1 and g.get_segment(varsOnodes[i]) == 1:258 disparity[row, col] = np.inf259 if varsAnodes[i] != -1 and g.get_segment(varsAnodes[i]) == 1:260 disparity[row, col] = alpha261 return handle_occlusion_scale(disparity)262def pairwise_term(g, n1, n2, A, B, C, D):263 g.add_tedge(n1, D, B)264 g.add_tedge(n2, 0, A - B)265 g.add_edge(n1, n2, 0, B + C - A - D)266def forbid01(g, n1, n2):267 g.add_edge(n1, n2, sys.maxsize, 0)268def is_var(v):269 return v != VAR_ALPHA and v != VAR_ABSENT270def calculate_k(alphaRange, image1, image2):271 K = int(alphaRange / 4)272 s = 0273 i = 0274 for r in range(alphaRange, image1.shape[0] - alphaRange):275 for c in range(alphaRange, image2.shape[1] - alphaRange):276 i += 1277 da_s = [squared_dissimilarity(image1, image2, (r, c), (r, c + alpha)) for alpha in range(alphaRange)]278 da_s.sort()279 s += da_s[K]280 return int(s / i)281def squared_dissimilarity(image1, image2, p1, p2):282 return (image1[p1] - image2[p2]) ** 2
interpret_grammar.py
Source:interpret_grammar.py
...11 # ignore the interpretation symbols 12 s = int_strip(s)13 pattern = fullmatch('u[0-9]*',s)14 return bool(pattern)15def is_var(s):16 # detect if string is a variable name, such as 'x12' (x followed by optional number)17 # ignore the interpretation symbols 18 s = int_strip(s)19 pattern = fullmatch('x[0-9]*',s)20 return bool(pattern)21def int_strip(s):22 # strip the interpretation symbols from a string23 s = s.replace('[','')24 s = s.replace(']','')25 return s26def to_interpet(s):27 # does s still need interpretation?28 return s[0] == '[' and s[-1] == ']'29class Grammar():30 max_recursion = 50 # maximum number of recursive calls31 count_recursion = 0 # recursive counters32 rules = []33 def __init__(self,rules,list_prims):34 # rules is a list of Rule objects35 # list_prims : list of primitive symbols36 self.rules = deepcopy(rules)37 for r in self.rules:38 r.set_primitives(list_prims)39 self.var_regexp = self.rules[-1].var_regexp #MAJOR HACK40 def apply(self,s, max_recursion_count=50):41 self.max_recursion = max_recursion_count42 self.count_recursion = 043 x = self.__apply_helper(s)44 # if self.count_recursion >= self.max_recursion:45 # print(x)46 return x47 def __apply_helper(self,s, return_list=False):48 self.count_recursion += 149 valid = []50 myrule = None51 for r in self.rules:52 valid.append(r.applies(s))53 # if np.count_nonzero(valid) != 1: # check that only one rule applies54 # assert False55 if not any(valid):56 return s57 myrule = self.rules[valid.index(True)]58 # run 'apply' recursively59 out = myrule.apply(s)60 for idx,o in enumerate(out):61 if to_interpet(o) and self.count_recursion < self.max_recursion:62 # print("WARNING: recursion depth exceeded")63 # break64 out[idx] = self.__apply_helper(int_strip(o))65 if return_list: 66 return out67 else:68 return ' '.join(out)69 def __str__(self):70 s = ''71 for r in self.rules:72 s += str(r)+'\n'73 return s74 def apply_once(self, s):75 self.max_recursion = 176 self.count_recursion = 077 return self.__apply_helper(s, return_list=True)78 def apply_repl(self, s, max_recursion_count=50):79 self.max_recursion = max_recursion_count80 self.count_recursion = 081 return self.__apply_helper_repl(s)82 def __apply_helper_repl(self, s, return_list=False):83 self.count_recursion += 184 valid = []85 myrule = None86 for r in self.rules:87 valid.append(r.applies(' '.join(s)))88 # if np.count_nonzero(valid) != 1: # check that only one rule applies89 # assert False90 if not any(valid):91 #print("no valid rules for", s)92 if fullmatch(self.var_regexp, ' '.join(s)):93 #if self.count_recursion == 1:94 # pass95 #else:96 return ['['] + s + [']'] #['[' + ' '.join(s) + ']']97 return s98 myrule = self.rules[valid.index(True)]99 # run 'apply' recursively100 out = myrule.apply(' '.join(s))101 for idx,o in enumerate(out):102 if to_interpet(o) and self.count_recursion < self.max_recursion:103 #if not self.count_recursion < self.max_recursion:104 # print(f'max recursion of {self.max_recursion} exceeded for miniscan repl')105 # import pdb; pdb.set_trace()106 out[idx] = self.__apply_helper_repl(int_strip(o).split(' '))107 else:108 out[idx] = o.split(' ')109 #if return_list: 110 return [token for oo in out for token in oo]111 #else:112 #return ' '.join(out)113 114class Rule():115 # left-hand-side116 LHS_str = ''117 LHS_list = []118 LHS_regexp = ''119 # right-hand-side120 RHS_str = ''121 RHS_list = []122 # 123 valid_rule = False124 var_regexp = '([ a-zA-Z0-9]+)'125 # var_regexp = '([ a-z]+)' # define acceptable string for a variable to hold126 127 def __init__(self,LHS,RHS):128 # LHS : string with variables (no interpretation symbols [ or ] )129 # RHS : string with variables (can have interpretation symbols for recursive computation)130 self.LHS_str = LHS131 self.LHS_list = LHS.split()132 self.RHS_str = RHS133 self.RHS_list = RHS.split()134 # self.RHS_list = split_special(RHS) 135 def set_primitives(self,list_prims):136 # list_prims : list of the primitive symbols137 self.list_prims = list_prims138 self.prim_regexp = '(' + '|'.join(self.list_prims) + ')' # define acceptable string for a primitive139 self.var_regexp = '([(' + '|'.join(self.list_prims + [' ']) + ')]+)'140 #print("hit this guy")141 #print(self.prim_regexp)142 #print(self.var_regexp)143 # get list of all variables in LHS144 self.vars = [v for v in self.LHS_list if is_prim(v) or is_var(v)]145 146 # sanity check 147 rhs_vars = [int_strip(v) for v in self.RHS_list if is_prim(v) or is_var(v)]148 self.valid_rule = all([v in self.vars for v in rhs_vars])149 # Compute the regexp for checking whether the rule is active150 mylist = deepcopy(self.LHS_list)151 for i,x in enumerate(mylist):152 if is_prim(x):153 mylist[i] = self.prim_regexp154 elif is_var(x):155 mylist[i] = self.var_regexp156 self.LHS_regexp = ' '.join(mylist)157 def applies(self,s, var_consistancy=False):158 # return True if the re-write rule applies to this string159 if not var_consistancy:160 return self.valid_rule and bool(fullmatch(self.LHS_regexp,s))161 else:162 if not self.valid_rule: return False163 m = fullmatch(self.LHS_regexp,s)164 if not bool(m): return False165 mygroups = m.groups()166 if not len(mygroups) == len(self.vars): return False167 vdict = dict(zip(self.vars,mygroups))168 for var, group in zip(self.vars, mygroups):169 if vdict[var] != group: return False170 return True171 def apply(self,s, var_consistancy=False):172 # apply rule to string s173 assert self.applies(s)174 assert self.valid_rule175 # if not self.valid_rule:176 # print(self)177 # assert False178 # extract variables from LHS179 m = fullmatch(self.LHS_regexp,s)180 #import pdb; pdb.set_trace()181 # if the expression has two variables "x1 x2", it returns the first split #TODO for var consistency182 mygroups = m.groups()183 assert(len(mygroups) == len(self.vars)), f"{mygroups}, {self.vars}, s={s}, rule={str(self)}"184 vdict = dict(zip(self.vars,mygroups))185 if var_consistancy:186 for var, group in zip(self.vars, mygroups):187 if vdict[var] != group: assert False188 # replace RHS with variable values189 mylist = deepcopy(self.RHS_list)190 for i,x in enumerate(mylist):191 if is_var(x) or is_prim(x):192 #import pdb; pdb.set_trace()193 mylist[i] = x.replace(int_strip(x), vdict[int_strip(x)])194 return mylist195 def __str__(self):196 if self.valid_rule:197 val_tag = ''198 else:199 val_tag = ' (invalid)'200 return str(self.LHS_str) + ' -> ' + str(self.RHS_str) + val_tag201if __name__ == "__main__":202 203 myrules = [Rule('walk','WALK'), Rule('u left','LTURN [u]'), Rule('x twice','[x] [x]')]204 G = Grammar(myrules,['walk','left'])205 print(G.apply('walk left twice'))206 print('Testing variable detector..')207 assert is_var('x')208 assert is_var('x0')209 assert is_var('x10')210 assert not is_var('X10')211 assert not is_var('10x')212 assert not is_var('y10')213 assert not is_var(' x10')214 assert not is_var('x10 ')...
alu.py
Source:alu.py
1VAR_W = 02VAR_X = 13VAR_Y = 24VAR_Z = 35class ALUSyntaxError(Exception):6 pass7class ALURuntimError(Exception):8 pass9class ALUEmulator:10 def __init__(self):11 self._vars = [0, 0, 0, 0]12 self.debug = False13 def set_debug(self, on_off):14 self.debug = on_off15 def exec(self, src_line, func, *args):16 if (self.debug):17 a = self.vars18 func(*args)19 b = self.vars20 print(f"DEBUG: {src_line:10s} {a} -> {b}")21 else:22 func(*args)23 @property24 def vars(self):25 return tuple(self._vars)26 @property27 def w(self):28 return self._vars[VAR_W]29 @property30 def x(self):31 return self._vars[VAR_X]32 @property33 def y(self):34 return self._vars[VAR_Y]35 @property36 def z(self):37 return self._vars[VAR_Z]38 def inp(self, var, value):39 self._vars[var] = value40 def add(self, arg1, arg2, is_var):41 self._vars[arg1] += self._vars[arg2] if is_var else arg242 def mul(self, arg1, arg2, is_var):43 self._vars[arg1] *= self._vars[arg2] if is_var else arg244 def div(self, arg1, arg2, is_var):45 right = self._vars[arg2] if is_var else arg246 self._vars[arg1] //= self._vars[arg2] if is_var else arg247 def mod(self, arg1, arg2, is_var):48 left = self._vars[arg1]49 right = self._vars[arg2] if is_var else arg250 self._vars[arg1] %= right51 def eql(self, arg1, arg2, is_var):52 compare_to = self._vars[arg2] if is_var else arg253 self._vars[arg1] = int(self._vars[arg1] == compare_to)54class ALUProgram():55 def __init__(self):56 self.instructions = []57 def add_instruction(self, instruction):58 self.instructions.append(instruction)59 def run(self, *args):60 alu = ALUEmulator()61 try:62 for instruction in self.instructions:63 args = instruction(alu, args)64 except IndexError:65 raise ALURuntimError("Not enough inputs provided for program")66 return alu.vars67class ALUCompiler:68 """The ALUCompiler can be used to translate ALU source code into69 a working ALU program."""70 def compile(self, src):71 """Compiles lines of source code into an ALU program."""72 program = ALUProgram()73 for line in src:74 src_line = line.strip()75 line = src_line76 if ";" in line:77 line = line[:line.index(";")]78 parts = line.lower().split()79 if not parts:80 continue81 instruction = None82 cmd = parts.pop(0)83 if cmd == "dbg":84 on_off = bool(parts.pop())85 instruction = self.make_dbg_instruction(src_line, on_off)86 elif cmd == "inp":87 var = self.get_var(line, parts)88 instruction = self.make_inp_instruction(src_line, var)89 elif cmd == "add":90 arg1 = self.get_var(line, parts)91 arg2, is_var = self.get_var_or_int(line, parts)92 instruction = self.make_add_instruction(src_line, arg1, arg2, is_var)93 elif cmd == "mul":94 arg1 = self.get_var(line, parts)95 arg2, is_var = self.get_var_or_int(line, parts)96 instruction = self.make_mul_instruction(src_line, arg1, arg2, is_var)97 elif cmd == "div":98 arg1 = self.get_var(line, parts)99 arg2, is_var = self.get_var_or_int(line, parts)100 instruction = self.make_div_instruction(src_line, arg1, arg2, is_var)101 elif cmd == "mod":102 arg1 = self.get_var(line, parts)103 arg2, is_var = self.get_var_or_int(line, parts)104 instruction = self.make_mod_instruction(src_line, arg1, arg2, is_var)105 elif cmd == "eql":106 arg1 = self.get_var(line, parts)107 arg2, is_var = self.get_var_or_int(line, parts)108 instruction = self.make_eql_instruction(src_line, arg1, arg2, is_var)109 else:110 raise ALUSyntaxError("Unknown operation:", line)111 if parts:112 raise ALUSyntaxError("Too many arguments:", line)113 program.add_instruction(instruction)114 return program115 def get_var_or_int(self, line, parts):116 try:117 value = int(parts[0])118 parts.pop(0)119 return value, False120 except (ValueError, IndexError):121 var = self.get_var(line, parts)122 return var, True123 def get_var(self, line, parts):124 if not parts:125 raise ALUSyntaxError("Missing argument(s):", line)126 name = parts.pop(0)127 if name == "w": return VAR_W128 if name == "x": return VAR_X129 if name == "y": return VAR_Y130 if name == "z": return VAR_Z131 raise ALUSyntaxError(f"Unknown variable name '{name}' used: {line}")132 def make_dbg_instruction(self, src_line, on_off):133 def instruction_(alu, args):134 alu.set_debug(on_off)135 return args136 return instruction_137 def make_inp_instruction(self, src_line, var):138 def instruction_(alu, args):139 value, args = args[0], args[1:]140 alu.exec(src_line, alu.inp, var, value)141 return args142 return instruction_143 def make_add_instruction(self, src_line, arg1, arg2, is_var):144 def instruction_(alu, args):145 alu.exec(src_line, alu.add, arg1, arg2, is_var)146 return args147 return instruction_148 def make_mul_instruction(self, src_line, arg1, arg2, is_var):149 def instruction_(alu, args):150 alu.exec(src_line, alu.mul, arg1, arg2, is_var)151 return args152 return instruction_153 def make_div_instruction(self, src_line, arg1, arg2, is_var):154 def instruction_(alu, args):155 alu.exec(src_line, alu.div, arg1, arg2, is_var)156 return args157 return instruction_158 def make_mod_instruction(self, src_line, arg1, arg2, is_var):159 def instruction_(alu, args):160 alu.exec(src_line, alu.mod, arg1, arg2, is_var)161 return args162 return instruction_163 def make_eql_instruction(self, src_line, arg1, arg2, is_var):164 def instruction_(alu, args):165 alu.exec(src_line, alu.eql, arg1, arg2, is_var)166 return args...
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Robotframework automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
