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