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