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