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