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