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