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