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