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