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