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