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