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