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