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