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