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