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