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