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