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