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