tree c8567a0828a24cfcc4fb4d4548aa69ed23e86b58
parent 69ac87248e1a5c18e80cf069a9dacf80b57bbde0
author dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> 1776065911 +0200
committer GitHub <noreply@github.com> 1776065911 +0200
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJp3J13CRC1aQ7uu5UhlAAAv8IQAG/pEKHyoN8srD6OpHtklPVM
 ixtGL+bCaTwMqQVy7+Cc7ONB7NPnReGN1iezHHS37sAP21MyLmyX/+sjavZjx8lM
 BWnEFmTd/F1pJQbuQ1ShWGfMXn0Xs90NlIFeQM+ncC/0uRqM7lLCXpQ9TX0XWC2O
 JIf0d0PRZJGIgV+0zUEN/3ZlumGT3iILdVSZlQsye6kIBTm3J806SPg8PvnjWPmd
 1LM5e71fDtdofW+l9pF3+6cWBQhvZp2KFnptAbkd7VZ67cHFic0zgHpAkOtaeDSi
 vfPTTUkgs3m+c1q3tk4nec9z6e4fACSDkF8I/eYh/1zGxP/a6Hm6KTNQ01PMX+MR
 jjYH/67dWc80sQR7Pb4orBqCczWnkrNOF0kj4PRx9ZnyvQAiDK+OD1jQESrIPu+B
 P1iby2bcRpBRifreyjEE7+j37lVfh/hLTM/BYJkxD+rCjZB2q2sCeEGYreMnzhoC
 9lwxVMfbd+wbvUV++b7fHFZX7ZLp4O/t41ypwrGzPCXscekJ7hSc8c8z9aGXucia
 Jgi26GHe2R9x7dy0aMmaB6Ee3vhwVrCWs0e0TGQQOLu4Xj/LslJwTr4hXZTqvvpf
 mok5BKm/euTQ+hijb0K5jlUfq9BF/CcSNLLcy8DtGOdt5mregyjpEh1sdbcRs8BP
 Q/wu/7rk3GNLc04dvVyg
 =SWbN
 -----END PGP SIGNATURE-----
 

Bump github/codeql-action from 4.31.7 to 4.35.1 (#1440)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.31.7 to 4.35.1.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/cf1bb45a277cb3c205638b2cd5c984db1c46a412...c10b8064de6f491fea524254123dbe5e09572f13)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.35.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Eugene Kliuchnikov <eustas.ru@gmail.com>