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