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