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