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