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