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