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