  # From sensor to lidar.
                lidar_to_sensor = car_egopose_to_sensor @ world_to_car_egopose @ lidar_to_world
                lidar_to_sensor = torch.from_numpy(lidar_to_sensor).float()

                # load image for debugging
                image_filename = os.path.join(
                    self.data_path, camera_sample['filename'])
                img = Image.open(image_filename)
                img = np.array(img)

                sparse_depth = torch.zeros((img.shape[:2]))

                # Ego(lidar) ==> Camera
                camera_points = torch.mm(
                    homo_ego_lidar_points, lidar_to_sensor.t())
                # depth > 0
                depth_mask = camera_points[:, 2] > 0
                camera_points = camera_points[depth_mask]
                # Camera ==> Pixel
                viewpad = torch.eye(4)
                viewpad[: intrinsic.shape[0], : intrinsic.shape[1]] = intrinsic
                pixel_points = torch.mm(camera_points, viewpad.t())[:, :3]
                pixel_points[:, :2] = pixel_points[:, :2] / \
                    pixel_points[:, 2:3]

                pixel_uv = pixel_points[:, :2].round().long()
                height, width = sparse_depth.shape
                valid_mask = (pixel_uv[:, 0] >= 0) & (
                    pixel_uv[:, 0] <= width - 1) & (pixel_uv[:, 1] >= 0) & (pixel_uv[:, 1] <= height - 1)

                valid_pixel_uv = pixel_uv[valid_mask]
                valid_depth = camera_points[..., 2][valid_mask]

                sparse_depth[valid_pixel_uv[:, 1], valid_pixel_uv[:, 0]] = valid_depth
                sparse_depth = sparse_depth.numpy()

                np.save(os.path.join(self.save_path, camera_sample['filename'][:-4] + '.npy'), sparse_depth)

            print('finish processing index = {:06d}'.format(index))

        sample_id_list = list(range(len(self.data)))
        with futures.ThreadPoolExecutor(num_workers) as executor:
            executor.map(process_one_sample, sample_id_list)

if __name__ == "__main__":
    model = DepthGenerator('val')
    model()


    code += "  public int " + camel_name;
        code += "Length";
        code += " { get";
        code += offset_prefix;
        code += "__p.__vector_len(o) : 0; ";
        code += "} ";
        code += "}\n";
        // See if we should generate a by-key accessor.
        if (field.value.type.element == BASE_TYPE_STRUCT &&
            !field.value.type.struct_def->fixed) {
          auto &sd = *field.value.type.struct_def;
          auto &fields = sd.fields.vec;
          for (auto kit = fields.begin(); kit != fields.end(); ++kit) {
            auto &key_field = **kit;
            if (key_field.key) {
              auto qualified_name = NamespacedName(sd);
              code += "  public " + qualified_name + "? ";
              code += Name(field) + "ByKey(";
              code += GenTypeGet(key_field.value.type) + " key)";
              code += offset_prefix;
              code += qualified_name + ".__lookup_by_key(";
              code += "__p.__vector(o), key, ";
              code += "__p.bb) : null; ";
              code += "}\n";
              break;
            }
          }
        }
      }
      // Generate a ByteBuffer accessor for strings & vectors of scalars.
      if ((IsVector(field.value.type) &&
           IsScalar(field.value.type.VectorType().base_type)) ||
          IsString(field.value.type)) {
        code += "#if ENABLE_SPAN_T\n";
        code += "  public Span<" + GenTypeBasic(field.value.type.VectorType()) +
                "> Get";
        code += Name(field);
        code += "Bytes() { return ";
        code += "__p.__vector_as_span<" +
                GenTypeBasic(field.value.type.VectorType()) + ">(";
        code += NumToString(field.value.offset);
        code +=
            ", " + NumToString(SizeOf(field.value.type.VectorType().base_type));
        code += "); }\n";
        code += "#else\n";
        code += "  public ArraySegment<byte>? Get";
        code += Name(field);
        code += "Bytes() { return ";
        code += "__p.__vector_as_arraysegment(";
        code += NumToString(field.value.offset);
        code += "); }\n";
        code += "#endif\n";

        // For direct blockcopying the data into a typed array
        code += "  public ";
        code += GenTypeBasic(field.value.type.VectorType());
        code += "[] Get";
        code += Name(field);
        code += "Array() { ";
        if (IsEnum(field.value.type.VectorType())) {
          // Since __vector_as_array does not work for enum types,
          // fill array using an explicit loop.
          code += "int o = __p.__offset(";
          code += NumToString(field.value.offset);
          code += "); if (o == 0) return null; int p = ";
          code += "__p.__vector(o); int l = ";
          code += "__p.__vector_len(o); ";
          code += GenTypeBasic(field.value.type.VectorType());
          code += "[] a = new ";
          code += GenTypeBasic(field.value.type.VectorType());
          code += "[l]; for (int i = 0; i < l; i++) { a[i] = " + getter;
          code += "(p + i * ";
          code += NumToString(InlineSize(field.value.type.VectorType()));
          code += "); } return a;";
        } else {
          code += "return ";
          code += "__p.__vector_as_array<";
          code += GenTypeBasic(field.value.type.VectorType());
          code += ">(";
          code += NumToString(field.value.offset);
          code += ");";
        }
        code += " }\n";
      }
      // generate object accessors if is nested_flatbuffer


rminatedString(message);
					break;

				case SEND_OPTIONS_MENU_OPEN:
					MenuOptionStruct mo = (MenuOptionStruct) payload;
					int numOptions = Math.min(mo.numOptions, 5);
					builder.writeByte((byte) numOptions);
					for (int i = 0; i < 5 && i < numOptions; i++){
						builder.writeByte(mo.optionTexts[i].length());
						builder.writeNonTerminatedString(mo.optionTexts[i]);
					}
					break;

				case SEND_STATS:
					StatInfoStruct si = (StatInfoStruct) payload;
					// 18 skills - current level
					builder.writeByte((byte) si.currentAttack);
					builder.writeByte((byte) si.currentDefense);
					builder.writeByte((byte) si.currentStrength);
					builder.writeByte((byte) si.currentHits);
					builder.writeByte((byte) si.currentRanged);
					builder.writeByte((byte) si.getCurrentPrayer());
					builder.writeByte((byte) si.getCurrentMagic());
					builder.writeByte((byte) si.currentCooking);
					builder.writeByte((byte) si.currentWoodcutting);
					builder.writeByte((byte) si.currentFletching);
					builder.writeByte((byte) si.currentFishing);
					builder.writeByte((byte) si.currentFiremaking);
					builder.writeByte((byte) si.currentCrafting);
					builder.writeByte((byte) si.currentSmithing);
					builder.writeByte((byte) si.currentMining);
					builder.writeByte((byte) si.currentHerblaw);
					builder.writeByte((byte) si.currentAgility);
					builder.writeByte((byte) si.currentThieving);

					// 18 skills - max level
					builder.writeByte((byte) si.maxAttack);
					builder.writeByte((byte) si.maxDefense);
					builder.writeByte((byte) si.maxStrength);
					builder.writeByte((byte) si.maxHits);
					builder.writeByte((byte) si.maxRanged);
					builder.writeByte((byte) si.getMaxPrayer());
					builder.writeByte((byte) si.getMaxMagic());
					builder.writeByte((byte) si.maxCooking);
					builder.writeByte((byte) si.maxWoodcutting);
					builder.writeByte((byte) si.maxFletching);
					builder.writeByte((byte) si.maxFishing);
					builder.writeByte((byte) si.maxFiremaking);
					builder.writeByte((byte) si.maxCrafting);
					builder.writeByte((byte) si.maxSmithing);
					builder.writeByte((byte) si.maxMining);
					builder.writeByte((byte) si.maxHerblaw);
					builder.writeByte((byte) si.maxAgility);
					builder.writeByte((byte) si.maxThieving);

					// 18 skills - experiences
					builder.writeInt(si.experienceAttack);
					builder.writeInt(si.experienceDefense);
					builder.writeInt(si.experienceStrength);
					builder.writeInt(si.experienceHits);
					builder.writeInt(si.experienceRanged);
					builder.writeInt(si.getExperiencePrayer());
					builder.writeInt(si.getExperienceMagic());
					builder.writeInt(si.experienceCooking);
					builder.writeInt(si.experienceWoodcutting);
					builder.writeInt(si.experienceFletching);
					builder.writeInt(si.experience


 x3, [x1]
        stp x2, x3, [x0]

        ldp x4, x5, [x1, 16]
        stp x4, x5, [x0, 16]
        ret

// void Fq_rawSwap(FqRawElement pRawResult, FqRawElement pRawA)
Fq_rawSwap:
_Fq_rawSwap:
        ldp  x3, x4, [x0]
        ldp  x7, x8, [x1]

        stp  x3, x4, [x1]
        stp  x7, x8, [x0]

        ldp  x5, x6,  [x0, 16]
        ldp  x9, x10, [x1, 16]

        stp  x5, x6,  [x1, 16]
        stp  x9, x10, [x0, 16]
        ret

// int Fq_rawIsEq(FqRawElement pRawA, FqRawElement pRawB)
Fq_rawIsEq:
_Fq_rawIsEq:
        ldp  x3, x4, [x0]
        ldp  x7, x8, [x1]
        eor x11, x3, x7
        eor x12, x4, x8

        ldp  x5, x6,  [x0, 16]
        ldp  x9, x10, [x1, 16]
        eor x13, x5, x9
        eor x14, x6, x10

        orr x15, x11, x12
        orr x16, x13, x14

        orr x0, x15, x16
        cmp  x0, xzr
        cset x0, eq
        ret

// int Fq_rawIsZero(FqRawElement rawA)
Fq_rawIsZero:
_Fq_rawIsZero:
        ldp x1, x2, [x0]
        orr x5, x1, x2

        ldp x3, x4, [x0, 16]
        orr x6, x3, x4

        orr  x0, x5, x6
        cmp  x0, xzr
        cset x0, eq
        ret

// void Fq_rawCopyS2L(FqRawElement pRawResult, int64_t val)
Fq_rawCopyS2L:
_Fq_rawCopyS2L:
        cmp  x1, xzr
        b.lt Fq_rawCopyS2L_adjust_neg

        stp x1,  xzr, [x0]
        stp xzr, xzr, [x0, 16]
        ret

Fq_rawCopyS2L_adjust_neg:
        adr x3, Fq_rawq
        ldp x5, x6, [x3]
        ldp x7, x8, [x3, 16]

        mov x9, -1

        adds x1, x1, x5
        adcs x2, x9, x6
        adcs x3, x9, x7
        adc  x4, x9, x8

        stp x1, x2, [x0]
        stp x3, x4, [x0, 16]
        ret

//int Fq_rawCmp(FqRawElement pRawA, FqRawElement pRawB)
Fq_rawCmp:
_Fq_rawCmp:
        ldp  x3, x4,  [x0]
        ldp  x5, x6,  [x0, 16]
        ldp  x7, x8,  [x1]
        ldp  x9, x10, [x1, 16]

        subs x3, x3, x7
        cset x0, ne

        sbcs x4, x4, x8
        cinc x0, x0, ne

        sbcs x5, x5, x9
        cinc x0, x0, ne

        sbcs x6, x6, x10
        cinc x0, x0, ne

        cneg x0, x0, lo
        ret


.youtube.com/watch?v=tN6-VYvstGM",
        "爱情有时很残忍" to "https://www.youtube.com/watch?v=H6TUN01DoQQ",
        "孤城" to "https://www.youtube.com/watch?v=ChRYTbz67IE",
        "虞兮叹" to "https://www.youtube.com/watch?v=ACmrAE4ov94",
        "科目三" to "https://www.youtube.com/watch?v=b3rFbkFjRrA",
        "起风了" to "https://www.youtube.com/watch?v=s5nFn4RgelA",
        "游京" to "https://www.youtube.com/watch?v=OjQ0KqCJOjk",
        "Everytime We Touch" to "https://www.youtube.com/watch?v=TQ_oIxIDKTA",
        "须尽欢" to "https://www.youtube.com/watch?v=LXDi5qNu4xA",
        "夜色" to "https://www.youtube.com/watch?v=aatVmb9ZCws",
        "快乐阿拉蕾" to "https://www.youtube.com/watch?v=4haZeezqMio",
        "别让爱凋落" to "https://www.youtube.com/watch?v=93U7ifus358",
        "跳楼机" to "https://www.youtube.com/watch?v=Hkd45-teUzg",
        "列车开往春天" to "https://www.youtube.com/watch?v=ZQg0ezB-q8g",
        "北京欢迎你" to "https://www.youtube.com/watch?v=_Pm80NKWuks",
        "赐我" to "https://www.youtube.com/watch?v=UwQjBW5pm1A",
        "樱花树下的约定" to "https://www.youtube.com/watch?v=8plzbfMYkCU",
        "忘川彼岸" to "https://www.youtube.com/watch?v=dhF0ANt9erI",
        "想某人" to "https://www.youtube.com/watch?v=xWegMGxyetY",
        "折风渡夜" to "https://www.youtube.com/watch?v=vNRFV0SITFs",
        "姑娘在远方" to "https://www.youtube.com/watch?v=dSOz373wvrk",
        "罗曼蒂克的爱情" to "https://www.youtube.com/watch?v=0tPahfiueJ0",
        "陪我过个冬" to "https://www.youtube.com/watch?v=o7pyoXc1-CM",
        "末班车" to "https://www.youtube.com/watch?v=7j16GT6DTEM",
        "最近" to "https://www.youtube.com/watch?v=nn2Z7EgdRpA",
        "如果爱忘了" to "https://www.youtube.com/watch?v=cKN20gqTTwk",
        "忘了" to "https://www.youtube.com/watch?v=paNgLF8tLjs",
        "把回忆拼好给你" to "https://www.youtube.com/watch?v=rFWcBkBRTkU",
        "满天星辰不及你" to "https://www.youtube.com/watch?v=bmnRFkpIunI",
        "爱不得忘不舍" to "https://www.youtube.com/watch?v=h1pzMFgNpcQ",
        "嘉宾" to


 *pTemp = ppmcontext->head;

  while(pTemp != 0) {
    int iTotal = 0;

    CPPMPYnode *pSymbol;
    for(i =0; i<DIVISION; i++){
      // std::cout<<"I "<<i<<std::endl;
      pSymbol = pTemp->child[i];
      //std::cout<<"Symbols "<<pSymbol->symbol<<std::endl;
      while(pSymbol) {
	int sym = pSymbol->symbol;

	if(!(exclusions[sym] && doExclusion))
	  iTotal += pSymbol->count;
	pSymbol = pSymbol->next;
      }
    }

    if(iTotal) {
      unsigned int size_of_slice = iToSpend;

      for(i=0; i<DIVISION; i++){
	pSymbol = pTemp->child[i];
	while(pSymbol) {
	  if(!(exclusions[pSymbol->symbol] && doExclusion)) {
	    exclusions[pSymbol->symbol] = 1;

	    unsigned int p = static_cast < myint > (size_of_slice) * (100 * pSymbol->count - beta) / (100 * iTotal + alpha);

	    if((pSymbol->symbol>-1)&&(pSymbol->symbol<GetSize())){
	      probs[pSymbol->symbol] += p;
	      iToSpend -= p;
	    }
	  }
	  //                              Usprintf(debug,TEXT("sym %u counts %d p %u tospend %u \n"),sym,s->count,p,tospend);
	  //                              DebugOutput(debug);
	  pSymbol = pSymbol->next;
	}
      }

    }
    pTemp = pTemp->vine;
  }

  unsigned int size_of_slice = iToSpend;
  int symbolsleft = 0;

  for(i = 1; i < iNumSymbols; i++)
    if(!(exclusions[i] && doExclusion))
      symbolsleft++;

//      std::ostringstream str;
//      for (sym=0;sym<modelchars;sym++)
//              str << probs[sym] << " ";
//      str << std::endl;
//      DASHER_TRACEOUTPUT("probs %s",str.str().c_str());

//      std::ostringstream str2;
//      for (sym=0;sym<modelchars;sym++)
//              str2 << valid[sym] << " ";
//      str2 << std::endl;
//      DASHER_TRACEOUTPUT("valid %s",str2.str().c_str());

  for(i = 1; i < iNumSymbols; i++) {
    if(!(exclusions[i] && doExclusion)) {
      unsigned int p = size_of_slice / symbolsleft;
      probs[i] += p;
      iToSpend -= p;
    }
  }

  int iLeft = iNumSymbols-1;

  for(int j = 1; j < iNumSymbols; ++j) {
    unsigned int p = iToSpend / iLeft;
    probs[j] += p;
    --iLeft;
    iToSpend -= p;
  }

  DASHER_ASSERT(iToSpend == 0);
}*/

void CPPMPYLanguageModel::GetPartProbs(Context context, std::vector<pair<symbol, unsigned int> > &vChildren, int norm, int iUniform){
  DASHER_ASSERT(!vChildren.empty());

  if(vChildren.size() == 1){
    vChildren[0].second = norm;
    return;
  }
  //  std::cout<<"Norms is "<<norm<<std::endl;
  //  std::cout<<"iUniform is "<<iUniform<<std::endl;

  const CPPMContext *ppmcontext = (const CPPMContext *)(context);

  //  DASHER_ASSERT(m_setContexts.count(ppmcontext) > 0);

  //  std::cout<<"size of context set  "<<m_setContexts.size()<<std::endl;

  //  probs.resize(iNumSymbols);

  unsigned int iToSpend = norm;
  unsigned int iUniformLeft = iUniform;

  // TODO: Sort out zero symbol case

  //Reproduce iterative calc


modifier_shadow_fiend_requiem_of_souls_lua_scepter = class({})

--------------------------------------------------------------------------------

function modifier_shadow_fiend_requiem_of_souls_lua_scepter:IsHidden()
	return false
	-- return true
end

function modifier_shadow_fiend_requiem_of_souls_lua_scepter:IsPurgable()
	return false
end
function modifier_shadow_fiend_requiem_of_souls_lua_scepter:GetAttributes()
	return MODIFIER_ATTRIBUTE_MULTIPLE
end
--------------------------------------------------------------------------------
-- Initializations
function modifier_shadow_fiend_requiem_of_souls_lua_scepter:OnCreated( kv )
	-- get references
	self.lines = kv.lineNumber
	self.duration = kv.lineDuration

	self.heal = 0

	-- Add timer
	if IsServer() then
		self:StartIntervalThink( self.duration )
	end
end

function modifier_shadow_fiend_requiem_of_souls_lua_scepter:OnRefresh( kv )
end

function modifier_shadow_fiend_requiem_of_souls_lua_scepter:OnDestroy()
	if IsServer() then
		if self.identifier then
			self:GetAbility():DelATValue( self.identifier )
		end
	end
end
----------------------------------------------------------


 unsafe.Sizeof(vv) == 4 {
			return serialize32(buf, uint32(vv)), 0
		} else {
			return serialize64(buf, uint64(vv)), 0
		}
	case string:
		if len(vv) > SonarMaxLen {
			return failure, 0
		}
		return uint8(copy(buf, vv)), SonarString
	case [1]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [2]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [3]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [4]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [5]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [6]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [7]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [8]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [9]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [10]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [11]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [12]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [13]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [14]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [15]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [16]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [17]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [18]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [19]byte:
		return uint8(copy(buf, vv[:])), SonarString
	case [20]byte:
		return uint8(copy(buf, vv[:])), SonarString
	default:
		// Special case: string literal is compared with a variable of
		// user type with string underlying type:
		//	type Name string
		//	var name Name
		//	if name == "foo" { ... }
		if _, ok := v2.(string); ok {
			s := *(*string)((*iface)(unsafe.Pointer(&v)).val)
			if len(s) <= SonarMaxLen {
				return uint8(copy(buf[:], s)), SonarString
			}
		}
		return failure, 0
	}
}

// The serialization routines here match those of encoding/binary.LittleEndian.
// They are copied here because importing encoding/binary creates import cycles.

func serialize16(buf []byte, v uint16) uint8 {
	_ = buf[1]
	buf[0] = byte(v >> 0)
	buf[1] = byte(v >> 8)
	return 2
}

func serialize32(buf []byte, v uint32) uint8 {
	_ = buf[3]
	buf[0] = byte(v >> 0)
	buf[1] = byte(v >> 8)
	buf[2] = byte(v >> 16)
	buf[3] = byte(v >> 24)
	return 4
}

func serialize64(buf []byte, v uint64) uint8 {
	_ = buf[7]
	buf[0] = byte(v >> 0)
	buf[1] = byte(v >> 8)
	buf[2] = byte(v >> 16)
	buf[3] = byte(v >> 24)
	buf[4]


 MeshType> bvh_M)
      : deformable_mesh_(std::move(deformable_mesh_M)),
        bvh_(std::move(bvh_M)),
        bvh_updater_(&mesh(), &bvh_) {}

  MeshType deformable_mesh_;
  Bvh<Aabb, MeshType> bvh_;
  BvhUpdater<MeshType> bvh_updater_;
};

template <typename T>
using DeformableVolumeMeshWithBvh = DeformableMeshWithBvh<VolumeMesh<T>>;
template <typename T>
using DeformableSurfaceMeshWithBvh =
    DeformableMeshWithBvh<TriangleSurfaceMesh<T>>;

}  // namespace internal
}  // namespace geometry
}  // namespace drake


Text -> {
                // for an editText we only style initial as styling the Editable causes problems!
                view.buildIconics()
            }
            is TextView -> {
                view.buildIconics()

                view.addTextChangedListener(object : TextWatcher {
                    override fun beforeTextChanged(cs: CharSequence, i: Int, i1: Int, i2: Int) {
                    }

                    override fun onTextChanged(cs: CharSequence, i: Int, i1: Int, i2: Int) {
                    }

                    override fun afterTextChanged(editable: Editable) {
                        Iconics.styleEditable(editable)
                    }
                })
            }
            is ImageView -> {
                IconicsAttrsApplier.getIconicsDrawable(context, attrs)?.let {
                    view.setImageDrawable(view.tryToEnableIconicsAnimation(it))
                }
            }
        }
    }
}/*
 * Copyright 2020 Mike Penz
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.mikepenz.iconics.animation

import android.view.View
import com.mikepenz.iconics.IconicsDrawable

fun View.tryToEnableIconicsAnimation(drawable: IconicsDrawable?): IconicsDrawable? {
    (drawable as? IconicsAnimatedDrawable)?.let { drawable.animateIn(this) }
    return drawable
}

fun View.tryToEnableIconicsAnimation(vararg drawables: IconicsDrawable?) {
    drawables.mapNotNull { (it as? IconicsAnimatedDrawable) }.forEach { it.animateIn(this) }
}/*
 * Copyright 2020 Mike Penz
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.mikepenz.iconics.animation

import android.animation.TimeInterpolator
import android.graphics.Canvas
import android.graphics.Paint
import android.text.TextPaint
import androidx.annotation.IntRange
import com.mikepenz.iconics.IconicsBrush
import com.mikepenz.iconics.animation.IconicsAnimationProcessor.RepeatMode.REVERSE

/**
 * @author pa.gulko zTrap (30.11.2018)
 */
open class BlinkAlphaProcessor(
    /** The minimal available alpha. */
    @IntRange(from = 0, to = 255) open var minimumAlpha: Int = 0,
    /** The maximal available alpha. */
    @IntRange(from = 0, to = 255) open var maximumAlpha: Int = 255,

    override var interpolator: TimeInterpolator = DEFAULT_INTERPOLATOR,
    override var duration: Long = DEFAULT_DURATION,
    override var repeatCount: Int = INFINITE,
    override var repeatMode: IconicsAnimationProcessor.RepeatMode = REVERSE,
    override var isStartImmediately: Boolean = true
) : IconicsAnimationProce


/* SPDX-License-Identifier: GPL-2.0-only */
/*
 *  linux/arch/arm/mm/proc-v7m.S
 *
 *  Copyright (C) 2008 ARM Ltd.
 *  Copyright (C) 2001 Deep Blue Solutions Ltd.
 *
 *  This is the "shell" of the ARMv7-M processor support.
 */
#include <linux/linkage.h>
#include <linux/cfi_types.h>
#include <asm/assembler.h>
#include <asm/page.h>
#include <asm/v7m.h>
#include "proc-macros.S"

SYM_TYPED_FUNC_START(cpu_v7m_proc_init)
	ret	lr
SYM_FUNC_END(cpu_v7m_proc_init)

SYM_TYPED_FUNC_START(cpu_v7m_proc_fin)
	ret	lr
SYM_FUNC_END(cpu_v7m_proc_fin)

/*
 *	cpu_v7m_reset(loc)
 *
 *	Perform a soft reset of the system.  Put the CPU into the
 *	same state as it would be if it had been reset, and branch
 *	to what would be the reset vector.
 *
 *	- loc   - location to jump to for soft reset
 */
	.align	5
SYM_TYPED_FUNC_START(cpu_v7m_reset)
	ret	r0
SYM_FUNC_END(cpu_v7m_reset)

/*
 *	cpu_v7m_do_idle()
 *
 *	Idle the processor (eg, wait for interrupt).
 *
 *	IRQs are already disabled.
 */
SYM_TYPED_FUNC_START(cpu_v7m_do_idle)
	wfi
	ret	lr
SYM_FUNC_END(cpu_v7m_do_idle)

SYM_TYPED_FUNC_START(cpu_v7m_dcache_clean_area)
	ret	lr
SYM_FUNC_END(cpu_v7m_dcache_clean_area)

/*
 * There is no MMU, so here is nothing to do.
 */
SYM_TYPED_FUNC_START(cpu_v7m_switch_mm)
	ret	lr
SYM_FUNC_END(cpu_v7m_switch_mm)

.globl	cpu_v7m_suspend_size
.equ	cpu_v7m_suspend_size, 0

#ifdef CONFIG_ARM_CPU_SUSPEND
SYM_TYPED_FUNC_START(cpu_v7m_do_suspend)
	ret	lr
SYM_FUNC_END(cpu_v7m_do_suspend)

SYM_TYPED_FUNC_START(cpu_v7m_do_resume)
	ret	lr
SYM_FUNC_END(cpu_v7m_do_resume)
#endif

SYM_TYPED_FUNC_START(cpu_cm7_dcache_clean_area)
	dcache_line_size r2, r3
	movw	r3, #:lower16:BASEADDR_V7M_SCB + V7M_SCB_DCCMVAC
	movt	r3, #:upper16:BASEADDR_V7M_SCB + V7M_SCB_DCCMVAC

1:	str	r0, [r3]		@ clean D entry
	add	r0, r0, r2
	subs	r1, r1, r2
	bhi	1b
	dsb
	ret	lr
SYM_FUNC_END(cpu_cm7_dcache_clean_area)

SYM_TYPED_FUNC_START(cpu_cm7_proc_fin)
	movw	r2, #:lower16:(BASEADDR_V7M_SCB + V7M_SCB_CCR)
	movt	r2, #:upper16:(BASEADDR_V7M_SCB + V7M_SCB_CC


照顧的孩子進行對話。再次使用就可以解散那個孩子。","不管怎麼樣，<name>─使用這個口哨然後去見見你要保護的人!我相信孩子們一定很想見到你。"}, {"使用獸人孤兒哨與你即將在兒童週期間照顧的孩子進行對話。"}},
[173] = {"森林裡的狼人", {"黑暗的勢力正在籠罩暮色森林，而卡爾文主人正在努力驅除邪惡，保護夜色鎮人民的安全是我們的職責。","你覺得自己有能力加入我們嗎?","我以前也跟你想的一樣，因為對哨所的安逸悠閒感到絕望，我投靠了卡爾文主人。如果你想要證明自己的實力，不是只靠嘴皮子說說就可以的。","去找夜行織影狼人較量較量吧，他們經常在陽光樹林─陽光，哈!─和爛果園出沒。"}, {"為夜色鎮的卡洛爾殺掉6個夜行織影狼人。"}},
[174] = {"觀測星星", {"我的地精朋友考格答應過要幫我製造一個可以用來觀察星星的裝置。除了魔法之外，我相信還有別的理由可以解釋發生在這片森林中的奇怪變化。","根據考格的設計圖，我們的第一步得先去找根由手藝高超的工程師所做的青銅管。"}, {"夜色鎮的維克托·安特拉斯要你給他一根青銅管。"}},
[175] = {"觀測星星", {"根據考格的設計圖，現在我還需要一個東西來反射光線。我記得有個叫瑪麗的女人因為總是戴著單眼透鏡而在這一帶人人皆知，你可以去找找她，向她借一個反光鏡。我記得她曾經住在暮色森林南部……"}, {"找到瑪麗，說服她借給你一個反光鏡，用於維克托的計畫。"}},
[176] = {"懸賞:霍格", {"懸賞:霍格","巨型豺狼人霍格，現正在艾爾文森林西南部的樹林裡遊蕩。他成功地對抗了目前為止所有追捕他的行動。","暴風城已經為除去這只豺狼人設下了酬金，想得到酬金的獵手必須向閃金鎮的治安官杜漢提供�


build_with_hash_map_storage();

        let write_extent = Extent3i::from_min_and_shape(Point3i::fill(10), Point3i::fill(80));
        map.for_each_mut(&write_extent, |_p, value| *value = 1);

        let read_extent = Extent3i::from_min_and_shape(Point3i::ZERO, Point3i::fill(100));
        for p in read_extent.iter_points() {
            if write_extent.contains(p) {
                assert_eq!(map.get(p), 1);
            } else {
                assert_eq!(map.get(p), 0);
            }
        }
    }

    #[test]
    fn copy_extent_from_array_then_read() {
        let extent_to_copy = Extent3i::from_min_and_shape(Point3i::fill(10), Point3i::fill(80));
        let array = Array3x1::fill(extent_to_copy, 1);

        let mut map = BUILDER.build_with_hash_map_storage();

        copy_extent(&extent_to_copy, &array, &mut map);

        let read_extent = Extent3i::from_min_and_shape(Point3i::ZERO, Point3i::fill(100));
        for p in read_extent.iter_points() {
            if extent_to_copy.contains(p) {
                assert_eq!(map.get(p), 1);
            } else {
                assert_eq!(map.get(p), 0);
            }
        }
    }
}
// © 2018 <NAME>
// SPDX-License-Identifier: ISC

#![crate_type = "lib"]
#![crate_name = "sshidentify"]

//! The Rust `sshidentify` can be used to gain information about the
//! SSH key, that has been used for the current connection. The
//! public `get_ssh_info()` will traverse through the process tree
//! to find the parent sshd PID. Once found the PID is being used
//! to check the systemd journal for the key fingerprint having been
//! used for the connection. Last but not least the `~/.ssh/authorized_keys`
//! is being examined to find the public key for the fingerprint.
//!
//! NOTE: The resulting binary must be called with permissions to
//! access the system's systemd journal to be functional.
//!
//! # Example
//! ```
//! extern crate sshidentify;
//!
//! /// Print information about first gpiochip
//! fn main() {
//! 	let info = sshidentify::get_ssh_info().unwrap()
//!     println!("SSH Info: {:?}", info);
//! }
//! ```

extern crate nix;
extern crate libc;
extern crate systemd;
extern crate regex;
extern crate base64;
extern crate sha2;
extern crate md5;

use std::io;
use std::io::BufRead;
use sha2::Digest;

#[derive(Debug)]
struct ProcessInfo {
    pid: nix::unistd::Pid,
    ppid: nix::unistd::Pid,
    name: String,
}

#[derive(Debug)]
struct SSHLogInfo {
    username: String,
    ip: String,
    keytype: String,
    fingerprint: String,
    fptype: SSHFingerprintType,
}

#[derive(Debug)]
struct SSHPubKey {
    keytype: String,
    keydata: String,
    comment: String,
}

#[derive(Debug)]
pub enum SSHFingerprintType {
    MD5,
    SHA256,
}

#[derive(Debug)]
pub struct SSHInfo {
    /// type of the fingerprint found in the systemd journal
    pub fingerprint_type: SSHFingerprintType,
    /// fingerprint found in the systemd journal
    pub fingerprint: String,
    /// local username of the ssh connection
    pub use


(CombinedMode mode, InsnTree receiver, InsnTree key, InsnTree value, MethodInfo replacer) {
		super(mode, receiver, key, value, replacer);
	}

	public NormalListMapUpdaterInsnTree(UpdateOrder order, boolean isAssignment, InsnTree receiver, InsnTree key, InsnTree value, MethodInfo replacer) {
		super(order, isAssignment, receiver, key, value, replacer);
	}

	@Override
	public void emitBytecode(MethodCompileContext method) {
		this.receiver.emitBytecode(method);
		this.key.emitBytecode(method);
		this.value.emitBytecode(method);
		switch (this.mode) {
			case VOID, PRE, POST -> {
				throw new IllegalStateException("Updating List or Map not implemented yet.");
			}
			case VOID_ASSIGN -> {
				this.replacer.emitBytecode(method);
				method.node.visitInsn(POP);
			}
			case PRE_ASSIGN -> {
				this.replacer.emitBytecode(method);
			}
			case POST_ASSIGN -> {
				method.node.visitInsn(DUP_X2);
				this.replacer.emitBytecode(method);
				method.node.visitInsn(POP);
			}
		}
	}

	@Override
	public InsnTree asStatement() {
		return this.mode.isVoid() ? this : new NormalListMapUpdaterInsnTree(this.mode.asVoid(), this.receiver, this.key, this.value, this.replacer);
	}
}package builderb0y.scripting.bytecode.tree.instructions.update;

import org.objectweb.asm.Label;

import builderb0y.scripting.bytecode.MethodCompileContext;
import builderb0y.scripting.bytecode.MethodInfo;
import builderb0y.scripting.bytecode.tree.InsnTree;

import static builderb0y.scripting.bytecode.InsnTrees.*;

public class NullableListMapUpdaterInsnTree extends ListMapUpdaterInsnTree {

	public NullableListMapUpdaterInsnTree(CombinedMode mode, InsnTree receiver, InsnTree key, InsnTree value, MethodInfo replacer) {
		super(mode, receiver, key, value, replacer);
	}

	public NullableListMapUpdaterInsnTree(UpdateOrder order, boolean isAssignment, InsnTree receiver, InsnTree key, InsnTree value, MethodInfo replacer) {
		super(order, isAssignment, receiver, key, value, replacer);
	}

	@Override
	public void emitBytecode(MethodCompileContext method) {
		Label update = label(), end = label();

		this.receiver.emitBytecode(method);
		method.node.visitInsn(DUP);
		method.node.visitJumpInsn(IFNONNULL, update);
		method.node.visitInsn(POP);
		method.node.visitJumpInsn(GOTO, end);
		method.node.visitLabel(update);
		this.key.emitBytecode(method);
		this.value.emitBytecode(method);
		switch (this.mode) {
			case VOID, PRE, POST -> {
				throw new IllegalStateException("Updating List or Map not yet implemented.");
			}
			case VOID_ASSIGN -> {
				this.replacer.emitBytecode(method);
				method.node.visitInsn(POP);
			}
			case PRE_ASSIGN -> {
				this.replacer.emitBytecode(method);
			}
			case POST_ASSIGN -> {
				method.node.visitInsn(DUP_X2);
				this.replacer.emitBytecode(method);
				method.node.visitInsn(POP);
			}
		}
		method.node.visitLabel(end);
	}

	@Override
	public InsnTree asStatement() {
		return this.mode.isVoid() ? this : new NullableListMapUpdaterInsnTree(this.mode.asVoid(), this.receiver, this.key, this.value, this.replacer);
	}
}/** Copyright (c) 2011-2015, SpaceToad and the BuildCraft Team http://www.mod-bu


}

func (bnd *bndLobSlice) close() (err error) {
	defer func() {
		if value := recover(); value != nil {
			err = errR(value)
		}
	}()

	for n := 0; n < len(bnd.ociLobLocators); n++ {
		// free temporary lob
		C.OCILobFreeTemporary(
			bnd.stmt.ses.ocisvcctx,      //OCISvcCtx          *svchp,
			bnd.stmt.ses.srv.env.ocierr, //OCIError           *errhp,
			bnd.ociLobLocators[n])       //OCILobLocator      *locp,
		// free lob locator handle
		C.OCIDescriptorFree(
			unsafe.Pointer(bnd.ociLobLocators[n]), //void     *descp,
			C.OCI_DTYPE_LOB)                       //ub4      type );
	}
	stmt := bnd.stmt
	bnd.stmt = nil
	bnd.ocibnd = nil
	bnd.ociLobLocators = nil
	bytesPool.Put(bnd.buf)
	bnd.buf = nil
	bnd.readers = nil
	bnd.arrHlp.close()
	stmt.putBnd(bndIdxBinSlice, bnd)
	return nil
}
// Copyright 2014 Rana Ian. All rights reserved.
// Use of this source code is governed by The MIT License
// found in the accompanying LICENSE file.

package ora

/*
#include <stdlib.h>
#include <oci.h>
#include "version.h"
*/
import "C"
import "unsafe"

// Generate all the def[IU]int{8,16,32,16}.go from defUint16.go
//
// Generated from defUint16.go by go run gen.go

type defUint16 struct {
	ociDef
	ociNumber  []C.OCINumber
	isNullable bool
}

func (def *defUint16) define(position int, isNullable bool, rset *Rset) error {
	def.rset = rset
	def.isNullable = isNullable
	if def.ociNumber != nil {
		C.free(unsafe.Pointer(&def.ociNumber[0]))
	}
	def.ociNumber = (*((*[MaxFetchLen]C.OCINumber)(C.malloc(C.size_t(rset.fetchLen) * C.sizeof_OCINumber))))[:rset.fetchLen]
	return def.ociDef.defineByPos(position, unsafe.Pointer(&def.ociNumber[0]), C.sizeof_OCINumber, C.SQLT_VNU)
}

func (def *defUint16) value(offset int) (value interface{}, err error) {
	if def.nullInds[offset] < 0 {
		if def.isNullable {
			return Uint16{IsNull: true}, nil
		}
		return nil, nil
	}
	var uint16Value uint16
	on := def.ociNumber[offset]
	r := C.OCINumberToInt(
		def.rset.stmt.ses.srv.env.ocierr, //OCIError              *err,
		&on,                         //const OCINumber       *number,
		byteWidth16,                 //uword                 rsl_length,
		C.OCI_NUMBER_UNSIGNED,         //uword                 rsl_flag,
		unsafe.Pointer(&uint16Value)) //void                  *rsl );
	if r == C.OCI_ERROR {
		err = def.rset.stmt.ses.srv.env.ociError()
	}
	if def.isNullable {
		return Uint16{Value: uint16Value}, err
	}
	return uint16Value, err
}

func (def *defUint16) alloc() error { return nil }
func (def *defUint16) free() {
	def.arrHlp.close()
}

func (def *defUint16) close()


 Array<CoinDto>();
  }

  private nextCoins(coins: CoinDto[]): void {
    this.coinListSubject.next(coins);
  }

  private fetch() {
    this.coinGeckoRepositoryService.fetchCoins()
      .pipe(retry(3))
      .subscribe(response => this.nextCoins(response.body));
  }

  private init(): void {
    this.fetch();
  }
}
import { DentalCaseSimple } from './dental-case-simple.model';
import { Patient } from './patient.model';

export class PatientWithCases {
  patient: Patient;
  dentalCaseSimples: DentalCaseSimple[];

  static builder() {
    return new PatientWithCasesBuilder();
  }
}

export class PatientWithCasesBuilder {
  private patientWithCases: PatientWithCases;

  constructor() {
    this.patientWithCases = new PatientWithCases();
  }

  withPatient(patient: Patient): PatientWithCasesBuilder {
    this.patientWithCases.patient = patient;
    return this;
  }

  withCases(cases: DentalCaseSimple[]): PatientWithCasesBuilder {
    this.patientWithCases.dentalCaseSimples = cases;
    return this;
  }

  build() {
    return this.patientWithCases;
  }
}
import { expect } from 'chai';

import { Gandalf } from '../src';
import customEn from './custom/english';
import customEs from './custom/spanish';

describe('Test validate function', () => {
  before(() => {
    Gandalf.addMessages(customEn);
    Gandalf.addMessages(customEs, 'es');
  });

  it('should validate required|email with success', async () => {
    const data = { email: 'usertest@example.org' };
    const gandalf = new Gandalf(data, {
      email: 'required|email',
    });

    await gandalf.validate();

    expect(gandalf.errors).to.be.empty;
  });

  it('should validate array with fail', async () => {
    const data = { userId: 3 };
    const gandalf = new Gandalf(data, {
      userId: 'inArray:1,2,4',
    });

    await gandalf.validate();

    expect(gandalf.errors).to.not.be.empty;
  });

  it('should checks isValid function', async () => {
    const data = { email: 'usertest@.org' };
    const gandalf = new Gandalf(data, {
      email: 'email',
    });
    await gandalf.validate();

    expect(gandalf.isValid()).to.be.false;

    await gandalf.revalidate({ data: { email: 'usertest@example.org' } });
    expect(gandalf.isValid()).to.be.true;
  });

  it('should validate required|email with fail', async () => {
    const data = { email: 'stringquenoesunmail' };
    const gandalf = new Gandalf(data, {
      email: 'required|email',
    });

    await gandalf.validate();

    expect(gandalf.errors).to.not.be.empty;
    expect(gandalf.errors).to.haveOwnProperty('email');
    expect(gandalf.errors['email']).to.haveOwnProperty('email');
    expect(gandalf.errors['email']).to.not.haveOwnProperty('required');
  });

  it('should validate required|email with double fail', async () => {
    const data = { email: '' };
    const gandalf = new Gandalf(data, {
      email: 'email',
    });

    await gandalf.validate();

    expect(gandalf.errors).to.not.be.empty;
    expect(gandalf.errors).to.haveOwnProperty('email');


（一）供水水质、水压不符合国家规定标准的，处以一千元以上五千元以下罚款；

（二）擅自停止供水或者未履行停水通知义务的，处以二千元以上一万元以下罚款；

（三）未按规定检修供水设施或者在供水设施发生故障后未及时抢修的，处以一千元以上三千元以下罚款；

（四）未按规定采取应急供水措施的，处以三千元以上一万元以下罚款。

第五十六条 二次供水管理单位有下列行为之一的，由城市供水行政主管部门责令改正，并可按下列规定处罚：

（一）二次供水设施未按要求采取安全保护措施的，处以三千元以上一万元以下罚款；

（二）未按规定进行水质检测或未按规定对二次供水设施进行清洗、消毒的，处以五千元以上二万元以下罚款；

（三）二次供水水质不符合国家规定标准的，处以一千元以上五千元以下罚款。

第五十七条 违反本条例规定，有下列行为之一的，由城市供水行政主管部门责令改正，并可按下列规定处罚；造成损失的，应当依法承担赔偿责任；构成犯罪的，依法追究刑事责任：

（一）擅自改装、复装、迁移、启闭或者损坏城市公共供水设施的，处以一千元以上五千元以下罚款；

（二）将用水器具、再生水管道、供热管道以及可能污染供水水质的管道和设施与城市公共供水管道直接连接的，处以五千元以上二万元以下罚款；

（三）在城市公共供水管道上直接装泵抽水的，处以二千元以上一万元以下罚款；

（四）城市公共供水用户擅自改变用水性质的，处以一千元以上五千元以下罚款；

（五）城市公共供水用户对外转供水的，没收违法所得，并处以违法所得的一至三倍罚款；

（六）擅自将自建设施供水管网或二次供水设施与城市公共供水管道连通的，处以五千元以上二万元以下罚款；

（七）盗用城市公共供水的，责令补交水费，并处以应交水费的一至三倍罚款；

（八）在城市公共供水设施安全保


err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(435, avp.Mbit, 0, datatype.IPv4("127.0.0.1"))
	exp = net.IP([]byte("127.0.0.1"))
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(450, avp.Mbit, 0, datatype.Integer32(10))
	exp = int32(10)
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(450, avp.Mbit, 0, datatype.Integer64(10))
	exp = int64(10)
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(450, avp.Mbit, 0, datatype.OctetString("diam1"))
	exp = "diam1"
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(450, avp.Mbit, 0, datatype.QoSFilterRule("diam1"))
	exp = "diam1"
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(450, avp.Mbit, 0, datatype.UTF8String("diam1"))
	exp = "diam1"
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(450, avp.Mbit, 0, datatype.Unsigned32(10))
	exp = uint32(10)
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	args = diam.NewAVP(450, avp.Mbit, 0, datatype.Unsigned64(10))
	exp = uint64(10)
	if rply, err := diamAVPAsIface(args); err != nil {
		t.Error(err)
	} else if !reflect.DeepEqual(exp, rply) {
		t.Errorf("Expected<%T>: %v ,received<%T>: %v ", exp, exp, rply, rply)
	}

	now := time.Now()
	args = diam.NewAVP


rt!(!params.is_null());
			let scnm = params as *mut SCRIPTING_METHOD_PARAMS;
			let nm = unsafe { &mut *scnm };
			let name = u2s!(nm.name);
			let argv = unsafe { Value::unpack_from(nm.argv, nm.argc) };
			let rv = me.on_script_call(he, &name, &argv);
			let handled = if let Some(v) = rv {
				v.pack_to(&mut nm.result);
				true
			} else {
				false
			};
			handled
		},

    EVENT_GROUPS::HANDLE_METHOD_CALL => {
      assert!(!params.is_null());
      let scnm = params as *const METHOD_PARAMS;
      let nm = unsafe { & *scnm };
      let code: BEHAVIOR_METHOD_IDENTIFIERS = unsafe { ::std::mem::transmute((*nm).method) };
      use capi::scbehavior::BEHAVIOR_METHOD_IDENTIFIERS::*;

      // output values
      let mut method_value = Value::new();
      let mut is_empty = false;

      let handled = {

        // unpack method parameters
        use dom::event::MethodParams;
        let reason = match code {
          DO_CLICK => {
            MethodParams::Click
          },
          IS_EMPTY => {
            MethodParams::IsEmpty(&mut is_empty)
          },
          GET_VALUE => {
            MethodParams::GetValue(&mut method_value)
          },
          SET_VALUE => {
            // Value from Sciter.
            let payload = params as *const VALUE_PARAMS;
            let pm = unsafe { & *payload };
            MethodParams::SetValue(Value::from(&pm.value))
          },

          _ => {
            MethodParams::Custom((*nm).method, params)
          },
        };

        // call event handler
        let handled = me.on_method_call(he, reason);
        handled
      };

      if handled {
        // Pack values back to Sciter.
        match code {
          GET_VALUE => {
            let payload = params as *mut VALUE_PARAMS;
            let pm = unsafe { &mut *payload };
            method_value.pack_to(&mut pm.value);
          },

          IS_EMPTY => {
            let payload = params as *mut IS_EMPTY_PARAMS;
            let pm = unsafe { &mut *payload };
            pm.is_empty = is_empty as UINT;
          },

          _ => {},
        }
      }
      // we've done here
      handled
    },

		EVENT_GROUPS::HANDLE_TIMER => {
			assert!(!params.is_null());
			let scnm = params as *const TIMER_PARAMS;
			let nm = unsafe { & *scnm };
			let handled = me.on_timer(he, nm.timerId as u64);
			handled
		},

		EVENT_GROUPS::HANDLE_DRAW => {
			assert!(!params.is_null());
			let scnm = params as *const DRAW_PARAMS;
			let nm = unsafe { & *scnm };
			let handled = me.on_draw(he, nm.gfx, &nm.area, nm.layer);
			handled
		},

		// unknown `EVENT_GROUPS` notification
		_ => {
			eprintln!("[sciter] warning! unknown event group {:04X}", evtg as u32);
			false
		},
	};
	return result as BOOL;
}
<gh_stars>0
#![feature(proc_macro_hygiene, decl_macro)]
#[macro_use]
extern crate diesel;

#[macro_use]
extern


0][j] - f[2][j];
    vshr.s32        \arg6, \arg1, #1
    vshr.s32        \arg7, \arg3, #1
    vsub.s32        \arg6, \arg6, \arg3         //int32 e[2][j] = (f[1][j]>>1) - f[3][j];
    vadd.s32        \arg7, \arg1, \arg7         //int32 e[3][j] = f[1][j] + (f[3][j]>>1);
//  }
.endm

WELS_ASM_FUNC_BEGIN WelsDctT4_neon
    push        {r4}
    ldr         r4, [sp, #4]

    LOAD_4x4_DATA_FOR_DCT   d4, d5, d6, d7, r1, r2, r3, r4

    vsubl.u8    q0, d4, d6
    vsubl.u8    q1, d5, d7
    vtrn.s32    q0, q1
    vswp        d1, d2

    // horizontal transform
    DCT_ROW_TRANSFORM_TOTAL_16BITS      d0, d1, d2, d3, d4, d5, d6, d7

    // transform element
    MATRIX_TRANSFORM_EACH_16BITS    d0, d1, d2, d3

    //  vertical transform
    DCT_ROW_TRANSFORM_TOTAL_16BITS      d0, d1, d2, d3, d4, d5, d6, d7

    // transform element
    MATRIX_TRANSFORM_EACH_16BITS    d0, d1, d2, d3

    vst1.s16        {q0, q1}, [r0]!

    pop     {r4}
WELS_ASM_FUNC_END

WELS_ASM_FUNC_BEGIN WelsDctFourT4_neon
    push        {r4}
    ldr         r4, [sp, #4]

    LOAD_8x8_DATA_FOR_DCT   d16, d17, d18, d19, d20, d21, d22, d23, r1, r3

    vsubl.u8    q0, d16, d20
    vsubl.u8    q1, d17, d21
    vsubl.u8    q2, d18, d22
    vsubl.u8    q3, d19, d23
    MATRIX_TRANSFORM_EACH_16BITS    q0, q1, q2, q3

    // horizontal transform
    DCT_ROW_TRANSFORM_TOTAL_16BITS      q0, q1, q2, q3, q8, q9, q10, q11

    // transform element
    MATRIX_TRANSFORM_EACH_16BITS    q0, q1, q2, q3

    //  vertical transform
    DCT_ROW_TRANSFORM_TOTAL_16BITS      q0, q1, q2, q3, q8, q9, q10, q11

    vswp        d1, d2
    vswp        d5, d6
    vswp        q1, q2
    vst1.s16        {q0, q1}, [r0]!
    vst1.s16        {q2, q3}, [r0]!

    ////////////////
    LOAD_8x8_DATA_FOR_DCT   d16, d17, d18, d19, d20, d21, d22, d23, r1, r3

    vsubl.u8    q0, d16, d20
    vsubl.u8    q1, d17, d21
    vsubl.u8    q2, d18, d22
    vsubl.u8    q3, d19, d23
    MATRIX_TRANSFORM_EACH_16BITS    q


00",
  "lastModifiedDateTime": "2017-01-01T00:00:35.1329464-08:00",
  "isFeatured": true,
  "privacyInformationUrl": "https://example.com/privacyInformationUrl/",
  "informationUrl": "https://example.com/informationUrl/",
  "owner": "Owner value",
  "developer": "Developer value",
  "notes": "Notes value",
  "uploadState": 11,
  "publishingState": "processing",
  "isAssigned": true,
  "roleScopeTagIds": [
    "Role Scope Tag Ids value"
  ],
  "dependentAppCount": 1,
  "supersedingAppCount": 3,
  "supersededAppCount": 2,
  "committedContentVersion": "Committed Content Version value",
  "fileName": "File Name value",
  "size": 4,
  "bundleId": "Bundle Id value",
  "applicableDeviceType": {
    "@odata.type": "microsoft.graph.iosDeviceType",
    "iPad": true,
    "iPhoneAndIPod": true
  },
  "minimumSupportedOperatingSystem": {
    "@odata.type": "microsoft.graph.iosMinimumOperatingSystem",
    "v8_0": true,
    "v9_0": true,
    "v10_0": true,
    "v11_0": true,
    "v12_0": true,
    "v13_0": true,
    "v14_0": true,
    "v15_0": true,
    "v16_0": true
  },
  "expirationDateTime": "2016-12-31T23:57:57.2481234-08:00",
  "versionNumber": "Version Number value",
  "buildNumber": "Build Number value"
}
```
---
title: "Update userExperienceAnalyticsAppHealthAppPerformanceByAppVersion"
description: "Update the properties of a userExperienceAnalyticsAppHealthAppPerformanceByAppVersion object."
author: "jaiprakashmb"
localization_priority: Normal
ms.prod: "intune"
doc_type: apiPageType
---

# Update userExperienceAnalyticsAppHealthAppPerformanceByAppVersion

Namespace: microsoft.graph

> **Important:** Microsoft Graph APIs under the /beta version are subject to change; production use is not supported.

> **Note:** The Microsoft Graph API for Intune requires an [active Intune license](https://go.microsoft.com/fwlink/?linkid=839381) for the tenant.

Update the properties of a [userExperienceAnalyticsAppHealthAppPerformanceByAppVersion](../resources/intune-devices-userexperienceanalyticsapphealthappperformancebyappversion.md) object.

## Permissions
One of the following permissions is required to call this API. To learn more, including how to choose permissions, see [Permissions](/graph/permissions-reference).

|Permission type|Permissions (from least to most privileged)|
|:---|:---|
|Delegated (work or school account)|DeviceManagementConfiguration.ReadWrite.All, DeviceManagementManagedDevices.ReadWrite.All|
|Delegated (personal Microsoft account)|Not supported.|
|Application|DeviceManagementConfiguration.ReadWrite.All, DeviceManagementManagedDevices.ReadWrite.All|

## HTTP Request
<!-- {
  "blockType": "ignored"
}
-->
``` http
PATCH /deviceManagement/userExperienceAnalyticsAppHealthApplicationPerformanceByAppVersion/{userExperienceAnalyticsAppHealthAppPerformanceByAppVersionId}
```

## Request headers
|Header|Value|
|:---|:---|
|Authorization|Bearer <token> Required.|
|Accept|application/json|

## Request body
In the request body, supply a JSON representation for the [userExperienceAnalyticsAppHealthAppPerformanceByAppVersion](../resources/intune-devices-userexperienceanalyticsapphealthappperformancebyappversion.md)


n in the non-moving Unity application space.
                Matrix4x4 cameraParentTransform = (CachedCamera == null) || (CachedCamera.transform.parent == null) ? Matrix4x4.identity : CachedCamera.transform.parent.localToWorldMatrix;
                Matrix4x4 anchorTransform = this.anchorGO.transform.localToWorldMatrix;
                return cameraParentTransform.inverse * anchorTransform;
#else
                return this.anchorGO.transform.localToWorldMatrix;
#endif
            }
        }

        /// <summary>
        /// Creates a new instance of <see cref="SpatialAnchorsCoordinate"/>.
        /// </summary>
        /// <param name="cloudSpatialAnchor">The associated <see cref="CloudSpatialAnchor"/> to use for creation.</param>
        /// <param name="anchorGO">The <see cref="GameObject"/> representing this anchor.</param>
        public SpatialAnchorsCoordinate(CloudSpatialAnchor cloudSpatialAnchor, GameObject anchorGO)
            : base(cloudSpatialAnchor.Identifier)
        {
            this.CloudSpatialAnchor = cloudSpatialAnchor;
            this.anchorGO = anchorGO;
        }

        /// <inheritdoc/>
        protected override Vector3 CoordinateToWorldSpace(Vector3 vector)
        {
            return CoordinateTransform.MultiplyPoint(vector);
        }

        /// <inheritdoc/>
        protected override Quaternion CoordinateToWorldSpace(Quaternion quaternion)
        {
            return CoordinateTransform.rotation * quaternion;
        }

        /// <inheritdoc/>
        protected override Vector3 WorldToCoordinateSpace(Vector3 vector)
        {
            return CoordinateTransform.inverse.MultiplyPoint(vector);
        }

        /// <inheritdoc/>
        protected override Quaternion WorldToCoordinateSpace(Quaternion quaternion)
        {
            return CoordinateTransform.inverse.rotation * quaternion;
        }

        /// <inheritdoc/>
        public void Destroy()
        {
            UnityEngine.Object.Destroy(anchorGO);
        }
    }
}


# SPDX-FileCopyrightText: 2019 Limor Fried for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""
`line`
================================================================================

Various common shapes for use with displayio - Line shape!

* Author(s): Melissa LeBlanc-Williams

Implementation Notes
--------------------

**Software and Dependencies:**

* Adafruit CircuitPython firmware for the supported boards:
  https://github.com/adafruit/circuitpython/releases

"""

from adafruit_display_shapes.polygon import Polygon

__version__ = "2.0.6"
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_Display_Shapes.git"

class Line(Polygon):
    # pylint: disable=too-many-arguments,invalid-name, too-few-public-methods
    """A line.

    :param x0: The x-position of the first vertex.
    :param y0: The y-position of the first vertex.
    :param x1: The x-position of the second vertex.
    :param y1: The y-position of the second vertex.
    :param color: The color of the line.
    """

    def __init__(self, x0, y0, x1, y1, color):
        super().__init__([(x0, y0), (x1, y1)], outline=color)


�匪、反霸运动，是一个极其艰巨、复杂、尖锐的严重斗争，比之上半年征粮要困难紧张的多。地主阶级企图以拖延征粮时间来破坏这个运动，我们必须十分警惕，必须抓紧提早完成公粮征收这一个环节。而公粮征收确也是一个极其艰巨的任务，必须保证百分之百完成，否则不仅损害到整个国家的财政收支概算，而且拖住腿陷整个工作於被动，又损害到减租、退押、反霸运动的开展。因之我们提出各县应力争提早于十月能基本完成征粮任务。其办法如下：

   （一）找出正确土地产量材料，具体算账教育干部及群众，确认今年公粮任务已减轻很多（但也不能盲目乐观），打破某些落后干部及群众不负责任的、不符合实际盲目的叫重，以巩固按时按数完成任务的充分信心和决心。

    据我们了解很多县均未掌握田地通产材料，未确实算过负担占收入比例的账。有的只有空洞信心，有的仍在盲目叫重，这是完成征粮任务必须解决的首要问题。

   （二）进行预征即在公粮未分派到户以前，即应一面评通产量，一面按四九年每户实应负担数（特殊重的酌量减低）。视各县情况，先预征入仓四至五成，这样做既拉长入仓时间，减少困难，又在争取提前完成任务上有极大作用。

   （三）强调普遍深入的宣传及群众路线，广泛动员与组织一切可能的力量参加征粮，以减少阻力，造成运动。未开或正开人代会之县份，对分配任务预收公粮，应在人代会上讨论通过。

   （四）加紧仓库建筑修补，设备用具、干部、教育等一切准备工作。

   上述办法请速讨论布置进行。

   一九五零年九月

   来源：《川北工作主要材料汇集（一）》，川北区党委出版，1951年。

    [返回索引页面]

   Copyright (C)  2024  Marxist-Leninist-Maoist.

   Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section e


5f92346")),
    Pair("fullstory", UUID.fromString("263fd456-02d1-4a26-a35e-52ccaedad778")),
    Pair("getlago", UUID.fromString("e1a3866b-d3b2-43b6-b6d7-8c1ee4d7f53f")),
    Pair("qualaroo", UUID.fromString("b08e4776-d1de-4e80-ab5c-1e51dad934a2")),
    Pair("mailjet-sms", UUID.fromString("6ec2acea-7fd1-4378-b403-41a666e0c028")),
    Pair("teradata", UUID.fromString("aa8ba6fd-4875-d94e-fc8d-4e1e09aa2503")),
    Pair("qonto", UUID.fromString("f7c0b910-5f66-11ed-9b6a-0242ac120002")),
    Pair("intruder", UUID.fromString("3d15163b-11d8-412f-b808-795c9b2c3a3a")),
    Pair("breezometer", UUID.fromString("7c37685e-8512-4901-addf-9afbef6c0de9")),
    Pair("airbyte-pagerduty-source", UUID.fromString("2817b3f0-04e4-4c7a-9f32-7a5e8a83db95")),
    Pair("pivotal-tracker", UUID.fromString("d60f5393-f99e-4310-8d05-b1876820f40e")),
    Pair("timely", UUID.fromString("bc617b5f-1b9e-4a2d-bebe-782fd454a771")),
    Pair("emailoctopus", UUID.fromString("46b25e70-c980-4590-a811-8deaf50ee09f")),
    Pair("pocket", UUID.fromString("b0dd65f1-081f-4731-9c51-38e9e6aa0ebf")),
    Pair("close-com", UUID.fromString("dfffecb7-9a13-43e9-acdc-b92af7997ca9")),
    Pair("k6-cloud", UUID.fromString("e300ece7-b073-43a3-852e-8aff36a57f13")),
    Pair("posthog", UUID.fromString("af6d50ee-dddf-4126-a8ee-7faee990774f")),
    Pair("cart", UUID.fromString("bb1a6d31-6879-4819-a2bd-3eed299ea8e2")),
    Pair("twitter", UUID.fromString("d7fd4f40-5e5a-4b8b-918f-a73077f8c131")),
    Pair("weatherstack", UUID.fromString("5db8292c-5f5a-11ed-9b6a-0242ac120002")),
    Pair("elasticsearch", UUID.fromString("7cf88806-25f5-4e1a-b422-b2fa9e1b0090")),
    Pair("gcs", UUID.fromString("2a8c41ae-8c23-4be0-a73f-2ab10ca1a820")),
    Pair("slack", UUID.fromString("c2281cee-86f9-4a86-bb48-d23286b4c7bd")),
    Pair("looker", UUID.fromString("00405b19-9768-4e0c-b1ae-9fc2ee2b2a8c")),
    Pair("aha", UUID.fromString("81ca39dc-4534-4dd2-b848-b0cfd2c11fce")),
    Pair("bigquery", UUID.fromString("bfd1ddf8-ae8a-4620-b


p != null) {
      this.dirsToSkip = new HashSet<>(dirsToSkip);
    }

    this.filesToSkip = DEFAULT_FILES_TO_SKIP;
    if (filesToSkip != null) {
      this.filesToSkip = new HashSet<>(filesToSkip);
    }

    List<File> javaScriptFiles = getAllJavaScriptFiles(pathToExamples);
    TypeScriptCompiler compiler;

    if (V8Compiler.supportsV8()) {
      System.out.println("Using V8Compiler ...");
      compiler = getV8Compiler();
      run(javaScriptFiles, compiler, pathToExamples, pathToTypings);
    }

    if (NodeCompiler.supportsNode()) {
      System.out.println("Using NodeCompiler ...");
      compiler = getNodeCompiler();
      run(javaScriptFiles, compiler, pathToExamples, pathToTypings);
    }

    // skip EngineCompiler tests on Travis CI, because they are likely to fail
    if (Boolean.parseBoolean(System.getenv("TRAVIS"))) {
      System.out.println("Travis CI environment detected. Skipping EngineCompiler tests.");
    } else {
      System.out.println("Using EngineCompiler ...");
      compiler = getEngineCompiler();
      run(javaScriptFiles, compiler, pathToExamples, pathToTypings);
    }
  }

  private void run(List<File> javaScriptFiles, TypeScriptCompiler compiler,
      File pathToExamples, File pathToTypings) throws Exception {
    SourceFactory parentSourceFactory = new TypeScriptClassLoader(
        getClass().getClassLoader(), compiler, new InMemoryCache());

    for (File f : javaScriptFiles) {
      String name = f.getAbsolutePath();
      name = name.substring(pathToExamples.getAbsolutePath().length() + 1);

      System.out.print(name + " ... ");
      long start = System.currentTimeMillis();
      try {
        compile(f, compiler, parentSourceFactory, pathToTypings);
      } catch (Exception e) {
        System.out.println("FAILED (" + (System.currentTimeMillis() - start) + " ms)");
        throw e;
      }
      System.out.println("OK (" + (System.currentTimeMillis() - start) + " ms)");
    }
  }

  public static void main(String[] args) throws Exception {
    TestExamplesRunner runner = new TestExamplesRunner();
    runner.run(new File(args[0]), new File(args[1]), null, null);
  }
}
// Copyright 2015 Michel Kraemer
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package de.undercouch.vertx.lang.typescript.compiler;

import java.io.IOException;

/**
 * Compiles TypeScript source files
 * @author Michel Kraemer
 */
public interface TypeScriptCompiler {
  /**
   * Compiles the given TypeScript file
   * @param filename the name of the file to compile
   * @param sourceFactory the factory that loads source files
   * @return the generated code
   * @throws IOException if one of the source files to compile could not be loaded
   */
  String compile(String filename, SourceFactory sourceFactory) throws IOException;
}
// These color conversion functions written in Java are released into the public domain.
// They are provided "as is" without any warranty, express or implied.

public class Main {

	// rgb in 0..1
	public static double[] rgb_to_xyz(


glabel func_80AF2608
/* 000B8 80AF2608 27BDFFC8 */  addiu   $sp, $sp, 0xFFC8           ## $sp = FFFFFFC8
/* 000BC 80AF260C AFBF0014 */  sw      $ra, 0x0014($sp)
/* 000C0 80AF2610 848E02A6 */  lh      $t6, 0x02A6($a0)           ## 000002A6
/* 000C4 80AF2614 00803025 */  or      $a2, $a0, $zero            ## $a2 = 00000000
/* 000C8 80AF2618 24C302A6 */  addiu   $v1, $a2, 0x02A6           ## $v1 = 000002A6
/* 000CC 80AF261C 15C00003 */  bne     $t6, $zero, .L80AF262C
/* 000D0 80AF2620 00001025 */  or      $v0, $zero, $zero          ## $v0 = 00000000
/* 000D4 80AF2624 10000005 */  beq     $zero, $zero, .L80AF263C
/* 000D8 80AF2628 248302A6 */  addiu   $v1, $a0, 0x02A6           ## $v1 = 000002A6
.L80AF262C:
/* 000DC 80AF262C 846F0000 */  lh      $t7, 0x0000($v1)           ## 000002A6
/* 000E0 80AF2630 25F8FFFF */  addiu   $t8, $t7, 0xFFFF           ## $t8 = FFFFFFFF
/* 000E4 80AF2634 A4780000 */  sh      $t8, 0x0000($v1)           ## 000002A6
/* 000E8 80AF2638 84620000 */  lh      $v0, 0x0000($v1)           ## 000002A6
.L80AF263C:
/* 000EC 80AF263C 14400008 */  bne     $v0, $zero, .L80AF2660
/* 000F0 80AF2640 2404003C */  addiu   $a0, $zero, 0x003C         ## $a0 = 0000003C
/* 000F4 80AF2644 2405003C */  addiu   $a1, $zero, 0x003C         ## $a1 = 0000003


  include('comments'),

            # Attributes.
            # https://www.w3.org/TR/WGSL/#attributes
            # Mark the '@' and the attribute name as a decorator.
            (r'@', Name.Decorator, 'attribute'),

            # Keywords
            (r'(true|false)\b', Keyword.Constant),
            keyword_decl,
            keywords,
            keyword_reserved,

            # Predeclared
            predeclared_enums,
            predeclared_types,
            predeclared_type_generators,
            predeclared_type_alias_vectors,
            predeclared_type_alias_matrices,

            # Decimal float literals
            # https://www.w3.org/TR/WGSL/#syntax-decimal_float_literal
            # 0, with type-specifying suffix.
            (r'0[fh]', Number.Float),
            # Other decimal integer, with type-specifying suffix.
            (r'[1-9][0-9]*[fh]', Number.Float),
            #    Has decimal point, at least one digit after decimal.
            (r'[0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[fh]?', Number.Float),
            #    Has decimal point, at least one digit before decimal.
            (r'[0-9]+\.[0-9]*([eE][+-]?[0-9]+)?[fh]?', Number.Float),
            #    Has at least one digit, and has an exponent.
            (r'[0-9]+[eE][+-]?[0-9]+[fh]?', Number.Float),

            # Hex float literals
            # https://www.w3.org/TR/WGSL/#syntax-hex_float_literal
            (r'0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+([pP][+-]?[0-9]+[fh]?)?', Number.Float),
            (r'0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*([pP][+-]?[0-9]+[fh]?)?', Number.Float),
            (r'0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?', Number.Float),

            # Hexadecimal integer literals
            # https://www.w3.org/TR/WGSL/#syntax-hex_int_literal
            (r'0[xX][0-9a-fA-F]+[iu]?', Number.Hex),
            # Decimal integer literals
            # https://www.w3.org/TR/WGSL/#syntax-decimal_int_literal
            # We need two rules here because 01 is not valid.
            (r'[1-9][0-9]*[iu]?', Number.Integer),
            (r'0[iu]?', Number.Integer), # Must match last.

            # Operators and Punctuation
            (r'[{}()\[\],\.;:]', Punctuation),
            (r'->', Punctuation), # Return-type arrow
            (r'[+\-*/%&|<>^!~=]', Operator),

            # TODO: Treat context-depedendent names specially
            # https://www.w3.org/TR/WGSL/#context-dependent-name

            # Identifiers
            (ident_pattern_token, Name),

            # TODO: templates start and end tokens.
            # https://www.w3.org/TR/WGSL/#template-lists-sec
        ],
        'block_comment': [
            # https://www.w3.org/TR/WGSL/#block-comment
            (r'[^*/]+', Comment.Multiline),
            (r'/\*', Comment.Multiline, '#push'),
            (r'\*/', Comment.Multiline, '#pop'),
            (r'[*/]', Comment.Multiline),
        ],
    }


  dMIPFilterKaiser
            dMIPFilterLinearLightKaiser
    */

    bool        bBinaryAlpha;       // zero or one alpha channel

    bool        bNormalMap;         // Is a normal Map
    bool        bDuDvMap;           // Is a DuDv (EMBM) map

    bool        bAlphaBorder;       // make an alpha border
    bool        bBorder;            // make a color border
    tPixel      BorderColor;        // color of border

    bool        bFadeColor;         // fade color over MIP maps
    bool        bFadeAlpha;         // fade alpha over MIP maps

    tPixel      FadeToColor;        // color to fade to
    int         FadeToAlpha;        // alpha value to fade to (0-255)

    int         FadeToDelay;        // start fading after 'n' MIP maps

    int         FadeAmount;         // percentage of color to fade in

    int         BinaryAlphaThreshold;  // When Binary Alpha is selected, below this value, alpha is zero

    bool        bDitherColor;       // enable dithering during 16 bit conversion
    bool        bDitherEachMIPLevel;// enable dithering during 16 bit conversion for each MIP level (after filtering)
    bool        bGreyScale;         // treat image as a grey scale
    bool        bQuickCompress;         // Fast compression scheme
    bool        bForceDXT1FourColors;  // do not let DXT1 use 3 color representation

    // sharpening after creating each MIP map level
    // warp sharp filter parameters
    // look here for details:
    //
    // "Enhancement by Image-Dependent Warping",
    // IEEE Transactions on Image Processing, 1999, Vol. 8, No. 8, S. 1063
    // Nur Arad and Craig Gotsman
    // http://www.cs.technion.ac.il/~gotsman/AmendedPubl/EnhancementByImage/EnhancementByI-D.pdf

    bool bSharpenEachMIPLevel;
    int SharpenEdgeRadius;
    float SharpenLambda;
    float SharpenMu;
    float SharpenTheta;
    bool bSharpenUseTwoComponents;
    bool bSharpenNonMaximalSuppression;
    bool bSharpenSharpBlur;
    bool bSharpenFlavor2;

    // gamma value for Kaiser, Light Linear
    float FilterGamma;
    // alpha value for kaiser filter
    float FilterKaiserAlpha;
    // width of filter
    int FilterWidth;

    short  TextureType;        // regular decal, cube or volume
    /*
        for TextureType, specify one of:
            dTextureType2D
         dTextureTypeCube
            dTextureTypeImage
            dTextureTypeVolume
     */

    short  TextureFormat;
    /*
        for TextureFormat, specify any from dTextureFormatFirst to
        dTextureFormatLast

            dDXT1,
            dDXT1a,
            dDXT3,
            dDXT5,
            d4444,
            d1555,
            d565,
            d8888,
            d888,
            d555,
            dV8U8,
            dCxV8U8,

            d8,   // paletted
            dA8,            // alpha only

        */

    bool        bSwapRGB;           // swap color positions R and G

} CompressionOptions;

#endif


<HumanActor>,
}
#[derive(Debug, PartialEq, Clone)]
pub struct Skeleton {
  pub bones: Vec<Bone>
}

#[derive(Debug, PartialEq, Clone)]
pub struct Bone {
  pub name: String,
  pub parent_index: Option<usize>,

  pub position: [f32; 3],
  pub orientation: [f32; 4],
  pub scale_shear: [f32; 9]
}<filename>mods/galangua-common/src/app/game/tractor_beam_table.rs
pub const TRACTOR_BEAM_SPRITE_NAMES: [&str; 29] = [
    "beam00", "beam01", "beam02", "beam03", "beam04", "beam05",
    "beam06", "beam07", "beam08", "beam09", "beam10", "beam11",
    "beam12", "beam13", "beam14", "beam15", "beam16", "beam17",
    "beam18", "beam19", "beam20", "beam21", "beam22", "beam23",
    "beam24", "beam25", "beam26", "beam27", "beam28",
];

pub const TRACTOR_BEAM_Y_OFFSET_TABLE: [i32; 29] = [
     0,  0,  5,  9, 12, 14,
    17, 20, 22, 25, 28, 30,
    33, 36, 40, 41, 44, 47,
    49, 52, 55, 57, 60, 62,
    65, 68, 70, 73, 76,
];
<reponame>nathdobson/rust-public
use std::sync::{Condvar, Mutex, Arc};
use std::sync::mpsc::RecvError;
use std::mem;

#[doc(hidden)]
pub enum State<T> {
    Waiting,
    Ok(T),
    Err,
}

#[doc(hidden)]
pub type Inner<T> = Arc<(Mutex<State<T>>, Condvar)>;

pub struct Sender<T> (Option<Inner<T>>);

pub enum Receiver<T> {
    #[doc(hidden)]
    Waiting(Inner<T>),
    #[doc(hidden)]
    Ok(T),
    #[doc(hidden)]
    Err,
}

impl<T> Sender<T> {
    pub fn send(mut self, value: T) {
        if let Some(inner) = self.0.take() {
            let mut lock = inner.0.lock().unwrap();
            println!("Sending");
            *lock = State::Ok(value);
            inner.1.notify_one();
        }
    }
}

impl<T> Drop for Sender<T> {
    fn drop(&mut self) {
        if let Some(inner) = self.0.take() {
            let mut lock = inner.0.lock().unwrap();
            println!("Sending");
            *lock = State::Err;
            inner.1.notify_one();
        }
    }
}

impl<T> Receiver<T> {
    fn resolve(&mut self) {
        match self {
            Receiver::Waiting(inner) => {
                let mut lock = inner.0.lock().unwrap();
                loop {
                    match mem::replace(&mut *lock, State::Waiting) {
                        State::Ok(x) => {
                            mem::drop(lock);
                            *self = Receiver::Ok(x);
                            return;
                        }
                        State::Err => {
                            mem::drop(lock);
                            *self = Receiver::Err;
                            return;
                        }
                        State::Waiting => lock = inner.1.wait(lock).unwrap(),
                    }
                }
            }
            _ => {}
        }
    }
    pub fn get_mut(&mut self) -> Result<&mut T, RecvError> {
        self.resolve();
        match self {
            Receiver::Waiting(_) => unreachable!(),
            Receiver::Ok(x) => Ok(x),
            Receiver


@ 0x2006ca4

.pool
thumb_func_end LoadFromNARC_8

thumb_func_start Call_FS_CloseFile
Call_FS_CloseFile: @ 2006ca8 :thumb
	push    {r4,lr}
	mov     r4, r0

	blx     FS_CloseFile

	mov     r0, r4
	bl      free
	pop     {r4,pc}
thumb_func_end Call_FS_CloseFile

/* Input:
r0: Ptr to NARCFileHandler
r1: FileNr
r2: MallocFlags
*/
thumb_func_start Function_2006cb8_LoadFileInMemory
Function_2006cb8_LoadFileInMemory: @ 2006cb8 :thumb
	push    {r4-r6,lr}
	add     sp, #-0x8
	mov     r5, r0

	add     r0, #NARCFileHandler_50
	ldrh    r0, [r0] @ NARCFileHandler_50
	mov     r4, r1
	mov     r6, r2
	cmp     r0, r4
	bhi     branch_2006cce
	bl      ErrorHandling
branch_2006cce: @ 2006cce :thumb

	ldr     r2, [r5, #NARCFileHandler_StartOfBTAF]
	lsl     r1, r4, #3
	add     r2, #0xc
	add     r1, r2, r1
	mov     r0, r5
	mov     r2, #SeekFile_AbsPos
	blx     FS_SeekFile
	mov     r0, r5
	add     r1, sp, #0x4        @ FileStart
	mov     r2, #0x4
	blx     FS_ReadFile
	mov     r0, r5
	add     r1, sp, #0x0        @ FileEnd
	mov     r2, #0x4
	blx     FS_ReadFile

	ldr     r2, [r5, #NARCFileHandler_IMGStart]
	ldr     r1, [sp, #0x4]          @ FileStart
	add     r2, #0x8
	add     r1, r2, r1
	mov     r0, r5
	mov     r2, #SeekFile_AbsPos
	blx     FS_SeekFile

	ldr     r2, [sp, #0x0]          @ FileEnd
	ldr     r1, [sp, #0x4]          @ FileStart
	mov     r0, r6
	sub     r1, r2, r1
	bl      malloc
	mov     r4, r0
	beq     branch_2006d20
	ldr     r3, [sp, #0x0]
	ldr     r2, [sp, #0x4]
	mov     r0, r5
	mov     r1, r4
	sub     r2, r3, r2
	blx     FS_ReadFile
branch_2006d20: @ 2006d20 :thumb

	mov     r0, r4
	add     sp, #0x8
	pop     {r4-r6,pc}
thumb_func_end Function_2006cb8_LoadFileInMemory

/* Input:
r0: NARCFileHandler
r1: FileNr
r2: Destination
*/
thumb_func_start LoadFileFromNARCFileHandler
LoadFileFromNARCFileHandler: @ 2006d28 :thumb
	push    {r4-r6,lr}
	add     sp, #-0x8
	mov     r5, r0

	add     r0, #NARCFileHandler_50
	ldrh    r0, [r0]
	mov     r4, r1
	mov     r6, r2
	cmp     r0, r4          @ NrOfFilesInNARC > FileNr
	bhi     branch_2006d3e
	bl      ErrorHandling
branch_2006


          finally
            {
                _ = new FileInfo(fileToEdit)
                {
                    IsReadOnly = false,
                };
            }
        }

        [Theory]
        [InlineData("")]
        [InlineData(null)]
        public void EnsureFileEditable_FilePathNullOrEmpty_ShouldLogError(string filePath)
        {
            _logDate = DateTime.Now;

            Fs.EnsureFileEditable(filePath);

            Assert.True(_fixture.IsErrorMessageInLogFile(_logDate, ErrorLevel, ErrorMessage));
        }

        [Fact]
        public void EnsureFileEditable_FileDoesNotExist_ShouldLogError()
        {
            var testScenarioName = "FileDoesNotExist";
            string filePath = $"{_testFolder}\\{testScenarioName}";
            _logDate = DateTime.Now;

            Fs.EnsureFileEditable(filePath);

            Assert.True(_fixture.IsErrorMessageInLogFile(_logDate, ErrorLevel, ErrorMessage));
        }

        [Fact]
        public void EnsureFileEditable_FileIsNotReadOnly_ShouldNotModifyIsReadOnly()
        {
            var testScenarioName = "FileIsNotReadOnly";
            string filePath = $"{_testFolder}\\{testScenarioName}";
            FSTestsFixture.CreateFiles(_testFolder, new List<string> { testScenarioName });

            var originalFileInfo = new FileInfo(filePath);
            Fs.EnsureFileEditable(filePath);
            var newFileInfo = new FileInfo(filePath);

            Assert.False(originalFileInfo.IsReadOnly);
            Assert.False(newFileInfo.IsReadOnly);
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA1816:Dispose methods should call SuppressFinalize", Justification = "Testing purposes only")]
        public void Dispose()
        {
            FSTestsFixture.DeleteTempFolderForTest(_testFolder);
        }
    }
}


�票代码：688030）。

现阶段，山石网科掌握30项自主研发核心技术，申请560多项国内外专利。山石网科于2019年起，积极布局信创领域，致力于推动国内信息技术创新，并于2021年正式启动安全芯片战略。2023年进行自研ASIC安全芯片的技术研发，旨在通过自主创新，为用户提供更高效、更安全的网络安全保障。目前，山石网科已形成了具备“全息、量化、智能、协同”四大技术特点的涉及
基础设施安全、云安全、数据安全、应用安全、安全运营、工业互联网安全、信息技术应用创新、安全服务、安全教育等九大类产品服务，50余个行业和场景的完整解决方案。

![图片](https://mmbiz.qpic.cn/sz_mmbiz_gif/NGIAw2Z6vnLzibrp7C4HmazCNIQXMJIRxPibycdiaNQCI4PNojUk3eYCQDZs6c5zNMUkq7yFNeYQIxicAV33eHNdFA/640?wx_fmt=gif&from=appmsg&wxfrom=5&wx_lazy=1&wx_co=1&tp=webp "")

#  Cisco Webex 漏洞可让黑客通过会议链接获取代码执行权限
Rhinoer  犀牛安全   2025-05-05 16:00

![](https://mmbiz.qpic.cn/mmbiz_png/qvpgicaewUBkQ5YJHoFGVzHoiaXZ3e8hBq65voCFBvQIDKRROicYEZzaIqbrp1ta5Rw0xTr5GPjKriarhsQ1ojRO8g/640?wx_fmt=png&from=appmsg "")

思科发布了针对高严重性 Webex 漏洞的安全更新，该漏洞允许未经身份验证的攻击者使用恶意会议邀请链接获取客户端远程代码执行。

该安全漏洞编号为 CVE-2025-20236，是在 Webex 自定义 URL 解析器中发现的，可通过诱骗用户下载任意文件来利用该漏洞，从而使攻击者能够在低复杂度攻击中在运行未修补软件的系统上执行任意命令。

思科在本周发布的安全公告中解释道： “此漏洞是由于 Cisco Webex App 处理会议邀请链接时输入验证不足造成的。”

攻击者可以通过诱骗用户点击精心设计的会议邀请链接并下载任意文件来利用此漏洞。成功利用此漏洞可使攻击者以目标用户的权限执行任意命令。

无论操作系统或系统配置如何，此安全漏洞都会影响 Cisco Webex App 的安装。目前尚无


_proc_func(params, template_data, template_context)
				local conditional_proc_func = template.conditional_proc_func
				local condition_ok = not conditional_proc_func or conditional_proc_func(template_data, template_context)

				if is_check_ok and condition_ok then
					local active_proc_func = template.active_proc_func[proc_event_name]

					if active_proc_func then
						active = active_proc_func(params, template_data, template_context)
					end

					if active then
						activated_proc = true
						procced_proc_events[proc_event_name] = (procced_proc_events[proc_event_name] or 0) + 1
						self._active_start_time = t

						local num_wanted_stacks_to_add = template_add_child_proc_events[proc_event_name]

						if num_wanted_stacks_to_add and type(num_wanted_stacks_to_add) == "function" then
							num_wanted_stacks_to_add = num_wanted_stacks_to_add(params, template_data, template_context)
						end

						if num_wanted_stacks_to_add and num_wanted_stacks_to_add > 0 then
							local max_child_stacks = (self._template_override_data.max_stacks or child_template.max_stacks or 1 or 1) + math.abs(child_template.stack_offset or 0)
							local stacks_to_max = max_child_stacks - self._num_child_stacks
							local num_stacks_to_add = math.min(num_wanted_stacks_to_add, stacks_to_max)

							self:_add_child_buff_stack(t, num_stacks_to_add)
						end
					else
						self:_remove_child_buff_stack(t, self._num_child_stacks - 1)
					end
				end
			end
		end

		local clear_child_stacks_proc_events = template.clear_child_stacks_proc_events

		if clear_child_stacks_proc_events and clear_child_stacks_proc_events[proc_event_name] then
			local specific_proc_check = template.specific_check_proc_funcs and template.specific_check_proc_funcs[proc_event_name]

			if specific_proc_check then
				if specific_proc_check(params, template_data, template_context) then
					self:_remove_child_buff_stack(t, self._num_child_stacks - 1)
				end
			else
				self:_remove_child_buff_stack(t, self._num_child_stacks - 1)
			end
		end
	end

	self._active = active

	return activated_proc, procced_proc_events
end

return WeaponTraitActivatedParentProcBuff


: func(c *cli.Context) error {
			var err error
			f, ok := registry.NewFuncs[cfg.Driver]
			if !ok {
				fmt.Fprintf(os.Stderr, "Unknown filesystem driver '%s'\n", cfg.Driver)
				os.Exit(1)
			}
			drivers := revaconfig.StorageProviderDrivers(cfg)
			var fsStream events.Stream
			if cfg.Driver == "posix" {
				// We need to init the posix driver with 'scanfs' disabled
				drivers["posix"] = revaconfig.Posix(cfg, false, false)
				// Also posix refuses to start without an events stream
				fsStream, err = event.NewStream(cfg)
				if err != nil {
					fmt.Fprintf(os.Stderr, "Failed to create event stream for posix driver: %v\n", err)
					os.Exit(1)
				}
			}

			fs, err := f(drivers[cfg.Driver].(map[string]interface{}), fsStream, nil)
			if err != nil {
				fmt.Fprintf(os.Stderr, "Failed to initialize filesystem driver '%s'\n", cfg.Driver)
				return err
			}

			managingFS, ok := fs.(storage.UploadSessionLister)
			if !ok {
				fmt.Fprintf(os.Stderr, "'%s' storage does not support listing upload sessions\n", cfg.Driver)
				os.Exit(1)
			}

			var stream events.Stream
			if c.Bool("restart") || c.Bool("resume") {
				stream, err = event.NewStream(cfg)
				if err != nil {
					fmt.Fprintf(os.Stderr, "Failed to create event stream: %v\n", err)
					os.Exit(1)
				}
			}

			filter := buildFilter(c)
			uploads, err := managingFS.ListUploadSessions(c.Context, filter)
			if err != nil {
				return err
			}

			var (
				table *tablewriter.Table
				raw   []Session
			)

			if !c.Bool("json") {
				fmt.Println(buildInfo(filter))

				table = tablewriter.NewTable(os.Stdout, tablewriter.WithHeaderAutoFormat(tw.Off))
				table.Header([]string{"Space", "Upload Id", "Name", "Offset", "Size", "Executant", "Owner", "Expires", "Processing", "Scan Date", "Scan Result"})
			}

			for _, u := range uploads {
				ref := u.Reference()
				sr, sd := u.ScanData()

				session := Session{
					Space:      ref.GetResourceId().GetSpaceId(),
					ID:         u.ID(),
					Filename:   u.Filename(),
					Offset:     u.Offset(),
					Size:       u.Size(),
					Executant:  u.Executant(),
					SpaceOwner: u.SpaceOwner(),
					Expires:    u.Expires(),
					Processing: u.IsProcessing(),
					ScanDate:   sd,
					ScanResult: sr,
				}

				if c.Bool("json") {
					raw = append(raw, session)
				} else {
					table.Append([]string{
						session.Space,
						session.ID,
						session.Filename,
						strconv.FormatInt(session.Offset, 10),
						strconv.FormatInt(session.Size, 10),
						session.Executant.OpaqueId,
						session.SpaceOwner.GetOpaqueId(),
						session.Expires.Format(time.RFC3339),
						strconv.FormatBool(session.Processing),
						session.ScanDate.Format(time.RFC3339),
						session.ScanResult,
					})
				}

				switch {
				case c.Bool("restart"):
					if err := events.Publish(context.Background(), stream, events.RestartPostprocessing{
						UploadID:


S105AR"
[1] 53.37278
[1] "S103DF"
[1] "http://api.postcodes.io/postcodes/S103DF"
[1] 53.37262
[1] "S103AE"
[1] "http://api.postcodes.io/postcodes/S103AE"
[1] 53.37504
[1] "S103ED"
[1] "http://api.postcodes.io/postcodes/S103ED"
[1] 53.37426
[1] "S102LJ"
[1] "http://api.postcodes.io/postcodes/S102LJ"
[1] 53.37278
[1] "S102LJ"
[1] "http://api.postcodes.io/postcodes/S102LJ"
[1] 53.37278
[1] "S103EW"
[1] "http://api.postcodes.io/postcodes/S103EW"
[1] 53.37226
[1] "S103AG"
[1] "http://api.postcodes.io/postcodes/S103AG"
[1] 53.37226
[1] "S103EW"
[1] "http://api.postcodes.io/postcodes/S103EW"
[1] 53.37226
[1] "S105AD"
[1] "http://api.postcodes.io/postcodes/S105AD"
[1] 53.38046
[1] "S103ED"
[1] "http://api.postcodes.io/postcodes/S103ED"
[1] 53.37426
[1] "S103ED"
[1] "http://api.postcodes.io/postcodes/S103ED"
[1] 53.37426
[1] "S103FA"
[1] "http://api.postcodes.io/postcodes/S103FA"
[1] 53.37034
[1] "S103AF"
[1] "http://api.postcodes.io/postcodes/S103AF"
[1] 53.37341
[1] "S103DF"
[1] "http://api.postcodes.io/postcodes/S103DF"
[1] 53.37262
[1] "S103ED"
[1] "http://api.postcodes.io/postcodes/S103ED"
[1] 53.37426
[1] "S103AX"
[1] "http://api.postcodes.io/postcodes/S103AX"
[1] 53.37445
[1] "S103AP"
[1] "http://api.postcodes.io/postcodes/S103AP"
[1] 53.37418
[1] "S103AQ"
[1] "http://api.postcodes.io/postcodes/S103AQ"
[1] 53.3743
[1] "S103AS"
[1] "http://api.postcodes.io/postcodes/S103AS"
[1] 53.37402
[1] "S103BW"
[1] "http://api.postcodes.io/postcodes/S103BW"
[1] 53.37553
[1] "S103BW"
[1] "http://api.postcodes.io/postcodes/S103BW"
[1]


"""
Copyright (C) 2017, 申瑞珉 (Ruimin Shen)

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

import os
import argparse
import configparser
import logging
import logging.config
import yaml

import numpy as np
import nltk.cluster.kmeans

import utils.data
import utils.iou.numpy

def distance(a, b):
    return 1 - utils.iou.numpy.iou(-a, a, -b, b)

def get_data(paths):
    dataset = utils.data.Dataset(utils.data.load_pickles(paths))
    return np.concatenate([(data['yx_max'] - data['yx_min']) / utils.image_size(data['path']) for data in dataset.dataset])

def main():
    args = make_args()
    config = configparser.ConfigParser()
    utils.load_config(config, args.config)
    with open(os.path.expanduser(os.path.expandvars(args.logging)), 'r') as f:
        logging.config.dictConfig(yaml.load(f))
    cache_dir = utils.get_cache_dir(config)
    paths = [os.path.join(cache_dir, phase + '.pkl') for phase in args.phase]
    data = get_data(paths)
    logging.info('num_examples=%d' % len(data))
    clusterer = nltk.cluster.kmeans.KMeansClusterer(args.num, distance, args.repeats)
    try:
        clusterer.cluster(data)
    except KeyboardInterrupt:
        logging.warning('interrupted')
    for m in clusterer.means():
        print('\t'.join(map(str, m)))

def make_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('num', type=int)
    parser.add_argument('-r', '--repeats', type=int, default=np.iinfo(np.int).max)
    parser.add_argument('-c', '--config', nargs='+', default=['config.ini'], help='config file')
    parser.add_argument('-p', '--phase', nargs='+', default=['train', 'val', 'test'])
    parser.add_argument('--logging', default='logging.yml', help='logging config')
    return parser.parse_args()

if __name__ == '__main__':
    main()


,
            maxLength: 50
        },
        programShortName:{
            type: Schema.Types.String,
            required: true,
            trim: true,
            maxLength: 50
        },
        instituteShortName:{
            type: Schema.Types.String,
            required: true,
            trim: true,
            maxLength: 50
        },
        sem1:[{
            type: Schema.Types.String,
            required: true
        }],
        sem2:[{
            type: Schema.Types.String,
            required: true
        }],
        sem3:[{
            type: Schema.Types.String,
            required: true
        }],
        sem4:[{
            type: Schema.Types.String,
            required: true
        }],
        sem5:[{
            type: Schema.Types.String,
            required: true
        }],
        sem6:[{
            type: Schema.Types.String,
            required: true
        }],
        sem7:[{
            type: Schema.Types.String,
            required: true
        }],
        sem8:[{
            type: Schema.Types.String,
            required: true
        }],
        sem9:[{
            type: Schema.Types.String,
            required: false
        }],
        sem10:[{
            type: Schema.Types.String,
            required: false
        }],
    },
    {
        versionKey: false
    }
)

export const ProgramModel = model<Program>(DOCUMENT_NAME, schema, COLLECTION_NAME);import { Macroable } from '../types';

/**
 * Determines whether the given value is "macroable".
 *
 * The term "macroable" is used to identify objects or
 * functions that can be extended using the `macro()`
 * and `mixin()` functions.
 *
 * A value is considered "macroable" if:
 * - The value is NOT null
 * - The value is an object or a function
 * - The value's extension is NOT prevented _`(Object.isExtensible(value) === true)`_
 * - The value is NOT "sealed" _`(Object.isSealed(value) === false)`_
 * - The value is NOT "frozen" _`(Object.isFrozen(value) === false)`_
 *
 * @example
 * ```js
 * import { isMacroable } from '@vicgutt/macrojs';
 *
 * isMacroable(null); // false
 * isMacroable('hello'); // false
 * isMacroable(Object.seal({})); // false
 * isMacroable([]); // true
 * isMacroable({}); // true
 * isMacroable(Array); // true
 * isMacroable(() => {}); // true
 * isMacroable(document.querySelectorAll('body')); // true
 * ```
 */
export default function isMacroable(value: unknown): value is Macroable {
    if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
        return false;
    }

    /**
     * No need to check for `Object.isFrozen(value)` here as
     * `Object.isSealed(value)` returns `true` for the results of
     * both `Object.seal(value)` and  `Object.freeze(value)`.
     */
    return !Object.isSealed(value) && Object.isExtensible(value);
}
// import { Vector3 } from "../../../math/Vector3";
// import { G_BufferManager } from "../../base/buffer/BufferManager";
// import { SY } from "../../base/Sprite";
// import { BoxGeometry } from "./BoxGeometry";

// const _tempNormal = new Vector3();

// 	function getUv( faceDirVector, normal, uvA


-3.88 3.88a2.52 2.52 0 0 1-3.5 0 2.47 2.47 0 0 1 0-3.5l3.88-3.88a1 1 0 0 0-1.42-1.42l-3.88 3.89a4.48 4.48 0 0 0 6.33 6.33l3.89-3.88a1 1 0 1 0-1.42-1.42Zm8.58-12.08a4.49 4.49 0 0 0-6.33 0l-3.89 3.88a1 1 0 0 0 1.42 1.42l3.88-3.88a2.52 2.52 0 0 1 3.5 0 2.47 2.47 0 0 1 0 3.5l-3.88 3.88a1 1 0 1 0 1.42 1.42l3.88-3.89a4.49 4.49 0 0 0 0-6.33ZM8.83 15.17a1 1 0 0 0 1.1.22 1 1 0 0 0 .32-.22l4.92-4.92a1 1 0 0 0-1.42-1.42l-4.92 4.92a1 1 0 0 0 0 1.42Z"></path>
			</svg>

Calculating anomalies in time series datasets is difficult to do well. The simplest way to do it is to use basic thresholds. However, as we’ve previously blogged about, simple thresholds aren’t very accurate when trying to determine when things are actually going wrong. There are too many edge cases for them to work effectively.

Calculating anomalies in HTTP errors is relatively easy. We know that in general there should be a very low number of errors, so any spike is bad and therefore alertable. That’s why we use Service Level Objectives (SLOs) to calculate anomalies for our HTTP Error Rate notifications.

However, analyzing overall HTTP traffic behaves more similarly to Cloudflare Security Events: there’s some general baseline of events that is computed from historical trends. Any deviation from that baseline is alertable. Because of those similarities, we decided to use the same calculations for Traffic Anomalies notifications as we have previously used for Security Event notifications: z-scores. This involves comparing the current value to the average over a period of time. However, many standard deviations away from the average the current value is, is the z-score.

Plot of HTTP traffic against z-scores. The blue is the HTTP traffic, purple is the positive z-score bound of the traffic, and green is the negative z-score bound of the traffic

For Traffic Anomalies notifications, we’re comparing the traffic over the past 5 minutes (the short window) to the average of the traffic over the past 4 hours (the long window). Positive z-scores indicate a spike, and negative z-scores indicate a drop. If the current value is more than 3.5 standard deviations away from the average, we alert. We measure every 5 minutes, so we can alert on any traffic spike or drop in a timely fashion.

		<img src="https://cf-assets.www.cloudflare.com/zkvhlag99gkb/6A3BnkHW9bCc9JUuq2aOW7/40964ec23


,筛:"篩"
,赚:"賺"
,轭:"㗁"
,栈:"偡"
,颖:"巊"
,饷:"享"
,凯:"䁗"
,鳑:{"páng":0,"fáng":1}
,鲏:{"pí":0,"pī":1,"pì":2}
,悯:"㥸"
,渔:"㚥"
,痈:"㴩"
,贻:"㰘"
,锐:"銳"
,饴:"飴"
,铸:"佇"
,敛:"摙"
,涝:"労"
,衬:"襯"
,讧:"蕻"
,砺:"㕸"
,赌:"堵"
,胁:"脅"
,谘:"䨏"
,纹:"文"
,诬:"巫"
,雠:"儔"
,顽:"頑"
,蛰:"謺"
,冯:"馮"
,骥:"㻑"
,砖:"剸"
,碛:"㞓"
,镩:{"cuān":0,"chuàn":1,"cuàn":2}
,韧:"仞"
,颤:{"chàn":0,"zhàn":1,"shān":2,"zhan":3}
,飕:"嗖"
,疮:"刅"
,怆:"刱"
,恻:"㩞"
,涡:"渦"
,鳍:"䳢"
,拢:"䡁"
,鹎:"卑"
,䴙:"媲"
,䴘:{"tī":0,"tí":1}
,辇:"攆"
,凫:"乀"
,轼:"䤭"
,预:"㣃"
,喽:"嘍"
,凼:"圵"
,镬:"㕷"
,骤:{"zhòu":0,"zòu":1}
,钗:"釵"
,刍:"㕑"
,荛:"蕘"
,颈:"頚"
,桨:"奨"
,雳:"㕸"
,禅:"禪"
,锡:{"xī":0,"tì":1,"xí":2}
,铭:"䫤"
,鹗:"㗁"
,镀:"妬"
,钜:"倨"
,犊:"凟"
,磙:"䙛"
,诱:"亴"
,钝:"伅"
,帜:"㨖"
,铲:"剷"
,辊:"䙛"
,苋:"莧"
,赋:"㤔"
,镂:"鏤"
,鹄:{"gǔ":0,"hú":1,"gù":2}
,鹜:"鶩"
,剀:"剴"
,辫:"卞"
,翘:"翹"
,赵:"趙"
,屦:"倨"
,诀:"亅"
,沥:"㕸"
,䌽:"倸"
,肾:"侺"
,馈:"饋"
,澜:"瀾"
,诫:"丯"
,篑:"䰎"
,矶:"磯"
,饲:"㹭"
,辄:"䕪"
,纣:"㑳"
,纠:{"jiū":0,"jiǎo":1,"jiǔ":2}
,庞:{"páng":0,"lóng":1,"péng":2}
,赎:"塾"
,阑:"瀾"
,饺:"餃"


/** \file StdLog.h
 **	\date  2004-06-01
 **	\author grymse@alhem.net
**/
/*
Copyright (C) 2004-2011  Anders Hedstrom

This library is made available under the terms of the GNU GPL, with
the additional exemption that compiling, linking, and/or using OpenSSL
is allowed.

If you would like to use this library in a closed-source application,
a separate license agreement is available. For information about
the closed-source license agreement for the C++ sockets library,
please visit http://www.alhem.net/Sockets/license.html and/or
email license@alhem.net.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#ifndef _SOCKETS_StdLog_H
#define _SOCKETS_StdLog_H

#include "sockets-config.h"
#include <string>

#ifdef SOCKETS_NAMESPACE
namespace SOCKETS_NAMESPACE {
#endif

/** error level enum. */
typedef enum
{
	LOG_LEVEL_INFO = 0,
	LOG_LEVEL_WARNING,
	LOG_LEVEL_ERROR,
	LOG_LEVEL_FATAL
} loglevel_t;

class ISocketHandler;
class Socket;

/** \defgroup logging Log help classes */
/** Log class interface.
	\ingroup logging */
class StdLog
{
public:
	virtual ~StdLog() {}

	virtual void error(ISocketHandler *,Socket *,
		const std::string& user_text,
		int err,
		const std::string& sys_err,
		loglevel_t = LOG_LEVEL_WARNING) = 0;
};

#ifdef SOCKETS_NAMESPACE
}
#endif

#endif // _SOCKETS_StdLog_H


	return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	case fr_bw6761.Vector:
		if index >= len(pv) {
			return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	case fr_bls24317.Vector:
		if index >= len(pv) {
			return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	case fr_bls24315.Vector:
		if index >= len(pv) {
			return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	case fr_bw6633.Vector:
		if index >= len(pv) {
			return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	case tinyfield.Vector:
		if index >= len(pv) {
			return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	case babybear.Vector:
		if index >= len(pv) {
			return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	case koalabear.Vector:
		if index >= len(pv) {
			return errors.New("out of bounds")
		}
		_, err := pv[index].SetInterface(value)
		return err
	default:
		panic("invalid input")
	}
}

func iterate(v any) chan any {
	chValues := make(chan any)
	switch pv := v.(type) {
	case fr_bn254.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case fr_bls12377.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case fr_bls12381.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case fr_bw6761.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case fr_bls24317.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case fr_bls24315.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case fr_bw6633.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case tinyfield.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case babybear.Vector:
		go func() {
			for i := 0; i < len(pv); i++ {
				chValues <- &(pv)[i]
			}
			close(chValues)
		}()
	case koalabear.Vector:
		go func() {
			for i := 0; i < len(pv); i++


orrs    r5, r0
/* program user option */
    ldr     r1, = FLASH_OB_BASE
    str     r4, [r1, 0x00]
    str     r5, [r1, 0x04]
    bl      wait_pro


 org.junit.Test
import org.junit.runner.RunWith
import org.mockito.ArgumentMatchers.anyInt
import org.mockito.ArgumentMatchers.eq
import org.mockito.Mock
import org.mockito.kotlin.mock
import org.mockito.kotlin.whenever
import org.robolectric.ParameterizedRobolectricTestRunner

@HiltAndroidTest
@RunWith(ParameterizedRobolectricTestRunner::class)
@UninstallModules(SystemModule::class)
class GeocodingManagerTest(
  private val expectedAreaName: String,
  private val message: String,
  private val inputs: List<Pair<Coordinates, List<Address>>>,
) : BaseHiltTest() {
  @BindValue @Mock lateinit var geocoder: Geocoder
  @Inject lateinit var geocodingManager: GeocodingManager

  @Test
  fun `getAreaName() returns expected name`() = runWithTestDispatcher {
    inputs.forEach { (coordinates, addresses) ->
      setAddresses(coordinates.lat, coordinates.lng, addresses)
    }

    assertEquals(expectedAreaName, geocodingManager.getAreaName(BOUNDS), message)
  }

  private fun setAddresses(latitude: Double, longitude: Double, addresses: List<Address>) {
    whenever(geocoder.getFromLocation(eq(latitude), eq(longitude), anyInt())).thenReturn(addresses)
  }

  companion object {
    private const val N = 1.0
    private const val S = -1.0
    private const val E = 1.0
    private const val W = -1.0
    private val SW = Coordinates(S, W)
    private val NE = Coordinates(N, E)
    private val NW = Coordinates(N, W)
    private val SE = Coordinates(S, E)
    private val BOUNDS = Bounds(SW, NE)
    private val CENTER = BOUNDS.center()
    private const val LOCALITY = "Marambaia"
    private const val SUB_ADMIN_AREA = "Belém"
    private const val ADMIN_AREA1 = "Parà"
    private const val ADMIN_AREA2 = "State of Parà"
    private const val COUNTRY1 = "Brazil"
    private const val COUNTRY2 = "Uruguay"
    private const val MULTIPLE_REGIONS = "Multiple regions"
    private const val UNNAMED_AREA = "Unnamed area"
    private val level1Address1 = mockAddress(COUNTRY1)
    private val level1Address2 = mockAddress(COUNTRY2)
    private val level2Address1 = mockAddress(COUNTRY1, ADMIN_AREA1)
    private val level2Address2 = mockAddress(COUNTRY1, ADMIN_AREA2)
    private val nullLevel2Address = mockAddress(COUNTRY1, null)
    private val level3Address = mockAddress(COUNTRY1, ADMIN_AREA1, SUB_ADMIN_AREA)
    private val level4Address = mockAddress(COUNTRY1, ADMIN_AREA1, SUB_ADMIN_AREA, LOCALITY)

    private fun mockAddress(
      countryName: String? = null,
      adminArea: String? = null,
      subAdminArea: String? = null,
      locality: String? = null,
    ) =
      mock<Address> {
        whenever(it.countryName).thenReturn(countryName)
        whenever(it.adminArea).thenReturn(adminArea)
        whenever(it.subAdminArea).thenReturn(subAdminArea)
        whenever(it.locality).thenReturn(locality)
      }

    @JvmStatic
    @ParameterizedRobolectricTestRunner.Parameters
    fun data() =
      listOf(
        testCase(
          "$MULTIPLE_REGIONS, $COUNTRY1",
          "Points with matching country-only addresses",
          addresses(NE, level1Address1),
          addresses(CENTER, level1Address1),
        ),
        testCase(
          UNNAMED_AREA,
          "Points with distinct countries",
          addresses(CENTER, level1Address1),
          addresses(SW, level1Address2),
        ),
        testCase(
          "$ADMIN_AREA1, $COUNTRY1",
          "Points with matching admin areas",
          addresses(NE, level2Address1),
          addresses(NW, level2Address1),
        ),
        testCase(
          "$SUB_ADMIN_AREA, $


/* SPDX-License-Identifier: GPL-2.0-only */

#include <sar.h>
#include <chip.h>
#include <fw_config.h>
#include <baseboard/variants.h>
#include <acpi/acpi.h>
#include <acpi/acpigen.h>
#include <drivers/vpd/vpd.h>

const char *get_wifi_sar_cbfs_filename(void)
{
	return "wifi_sar_0.hex";
}

void variant_update_soc_chip_config(struct soc_intel_alderlake_config *config)
{
	if (fw_config_probe(FW_CONFIG(DB_LTE, LTE_USB))) {
		config->ext_fivr_settings.configure_ext_fivr = 1;
		config->ext_fivr_settings.v1p05_enable_bitmap = FIVR_ENABLE_ALL_SX;
		config->ext_fivr_settings.vnn_enable_bitmap = FIVR_ENABLE_ALL_SX;
		config->ext_fivr_settings.v1p05_supported_voltage_bitmap = FIVR_VOLTAGE_NORMAL |
								FIVR_VOLTAGE_MIN_ACTIVE |
								FIVR_VOLTAGE_MIN_RETENTION;
		config->ext_fivr_settings.vnn_supported_voltage_bitmap = FIVR_VOLTAGE_NORMAL |
								FIVR_VOLTAGE_MIN_ACTIVE |
								FIVR_VOLTAGE_MIN_RETENTION;
		config->ext_fivr_settings.v1p05_icc_max_ma = 500;
		config->ext_fivr_settings.vnn_sx_voltage_mv = 1250;
	}
}