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