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