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